-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1
On 07.04.2015 17:52, Guido van Rossum wrote:
On Apr 7, 2015 8:46 AM, "Paul Moore" <p.f.moore@gmail.com mailto:p.f.moore@gmail.com> wrote:
On 7 April 2015 at 15:54, Szymon Pyżalski <szymon@pythonista.net mailto:szymon@pythonista.net> wrote:
I was trying to google if there were some attempts to add pattern matching feature (as seen in e.g. haskell) to Python. I couldn't
however
find anything. Were there any proposals for a feature like this?
From a quick look:
https://pypi.python.org/pypi/patterns https://pypi.python.org/pypi/py-pattern-matching
Thanks these are nice but I think they try to mimic languages based on algebraic data types too much. I was thinking about something like this:
Magic method for patterns - -----------------------------
Any object can be a pattern. If an object has a special method (called ``__pattern__`` or ``__match__``) defined then this method will govern how this object behaves as pattern. If not - pattern matching works the same as ``__eq__``
The ``__pattern__`` method can return ``False`` for no match. For a match it can return ``True`` (simplest patterns) a sequence or a mapping .
Syntax for pattern matching - -------------------------------
The syntax could look something like this::
for object: pattern1: statement1 pattern2: statement2 statement3 pattern3 as var1, var2: statement4 statement5
For the simplest cases this works simply by calling appropriate statement block. If the ``__pattern__`` method returns a mapping, then the values from it will be merged into the local namespace. If it returns a sequence and there is the ``as`` clause, the values will be assigned to variables specified.
Quick idea: this might integrate well with PEP 484, or with the (still speculative) multiple dispatch that Lukas Lang wants to write.
Function dispatch - -----------------------[
Besides the above syntax the patterns could be also used to register functions for dispatching. I dont' know how precisely it would integrate with PEP 484, but I agree that any valid type hint should also be a valid pattern.
Existing objects as patterns - ----------------------------------
* Types should match their instances * Tuples should match sequences that have the same length and whose elements match against the elements of a tuple (subpatterns) * Dictionaries should match mappings that contain all the keys in the pattern and the values match the subpatterns under these keys * Regular expressions should match strings. For named groups they should populate the local namespace. * The ``Ellipsis`` object can be used as a match-all pattern.
Example - -----------
The code below would work if the ``point`` variable is specified as:
* a tuple (x, y) * a mapping {'x': x, 'y': y} * a string "{x}-{y}".format(x, y)
::
def print_point(x, y): print('x = {}'.format(x)) print('y = {}'.format(y))
for point: (Number, Number) as x, y: print_point(x, y) {'x': Number, 'y': Number}: print_point(x, y) re.compile('(?P<x>[0-9]+)-(?P<y>[0-9])+'): # Or re.compile('([0-9]+)-([0-9])+') as x, y: print_point(int(x), int(y)) ...: raise TypeError('Expected something else')
Greetings zefciu