[Python-Dev] Re: switch statement

[Michael Hudson]

Samuele Pedroni <pedronis at strakt.com> writes:

> Michael Hudson wrote:

[pattern matching]

>>Can you post a quick summary of how you think this would work?
>>
>>  
> Well, Python lists are used more imperatively and are not made up
> with cons cells, we have dictionaries which because of ordering
> issues are not trivial to match, and no general ordered records with
> labels.

That's a better way of putting it than "pattern matching and python
don't really seem to fit together", for sure :)

(I'd quite like records with labels, tangentially, but am not so wild
about ordering)

> We have objects and not algebraic data types. Literature on the
> topic usually indicates the visitor pattern as the moral equivalent
> of pattern matching in an OO-context vs. algebraic data
> types/functional one. I agree with that point of view and Python has
> idioms for the visitor pattern.

But the visitor pattern is pretty grim, really.  It would be nice (tm)
to have something like:

  match node in:
    Assign(lhs=Var(_), rhs=_):
       # lhs, rhs bound in here
    Assign(lhs=Subscr(_,_), rhs=_):
       # ditto
    Assign(lhs=Slice(*_), rhs=_):
       # ditto
    Assign(lhs=_, rhs=_):
       raise SyntaxError
     
in Lib/compiler.

Vyper had something like this, I think.

>
> Interestingly even in the context of objects one can leverage the
> infrastructure that is there for generalized copying/pickling to
> allow generalized pattern matching of nested object data
> structures. Whether it is practical I don't know.
>
>  >>> class Pt:
> ...   def __init__(self, x,y):
> ...     self.x = x
> ...     self.y = y
> ...
>  >>> p(lambda _: Pt(1, _()) ).match(Pt(1,3))
> (3,)
>  >>> p(lambda _: Pt(1, Pt(_(),_()))).match(Pt(1,Pt(Pt(5,6),3)))
> (<__main__.Pt instance at 0x40200b4c>, 3)
>
> http://codespeak.net/svn/user/pedronis/match.py is an experiment in
> that direction (preceding this discussion
> and inspired while reading a book that was using OCaml for its examples).

Yikes!

> Notice that this is quite grossly subclassing pickling infrastracture
> (the innocent bystander should probably not try that), a cleaner
> approach redoing that logic with matching in mind is possible and
> would be preferable.

Also, the syntax is disgusting.  But that's a separate issue, I guess.

Cheers,
mwh

-- 
  /* I'd just like to take this moment to point out that C has all
     the expressive power of two dixie cups and a string.
   */                       -- Jamie Zawinski from the xkeycaps source