Path: csiph.com!usenet.pasdenom.info!aioe.org!news.stack.nl!newsfeed.xs4all.nl!newsfeed3.news.xs4all.nl!xs4all!post.news.xs4all.nl!not-for-mail
MIME-Version: 1.0
In-Reply-To: <877g8ff3hn.fsf@elektro.pacujo.net>
References: <27ac2248-0ca3-4ba6-9d25-eaad324bc5e9@googlegroups.com> <bd36a46b-d704-4eb1-9b7d-1308d1fb6699@googlegroups.com> <mailman.7435.1393523704.18130.python-list@python.org> <5f4f5a5f-327a-4616-8235-17ee9e74c488@googlegroups.com> <530fef58$0$11113$c3e8da3@news.astraweb.com> <e24e0817-67d1-4dbd-b3ba-9250e735d261@googlegroups.com> <mailman.7453.1393562612.18130.python-list@python.org> <871tynznpd.fsf@elektro.pacujo.net> <53104798$0$11113$c3e8da3@news.astraweb.com> <mailman.7460.1393577227.18130.python-list@python.org> <87ha7jy2qs.fsf@elektro.pacujo.net> <5310b031$0$29985$c3e8da3$5496439d@news.astraweb.com> <db181305-97fe-4385-bf11-5323d4bd1160@googlegroups.com> <87iorzf4ro.fsf@elektro.pacujo.net> <mailman.7479.1393613988.18130.python-list@python.org> <877g8ff3hn.fsf@elektro.pacujo.net>
Date: Sat, 1 Mar 2014 12:50:21 +1100
Subject: Re: Can global variable be passed into Python function?
From: Chris Angelico <rosuav@gmail.com>
Cc: "python-list@python.org" <python-list@python.org>
Content-Type: text/plain; charset=UTF-8
Precedence: list
Newsgroups: comp.lang.python
Message-ID: <mailman.7493.1393638625.18130.python-list@python.org>
Lines: 66
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: csiph.com comp.lang.python:67279

On Sat, Mar 1, 2014 at 6:20 AM, Marko Rauhamaa <marko@pacujo.net> wrote:
> Your example:
>
>     compare_key = {
>         # Same target(s).
>         ast.Assign: lambda node: ' '.join(dump(t) for t in node.targets),
>         # Same target and same operator.
>         ast.AugAssign: lambda node: dump(node.target) + dump(node.op) + "=",
>         # A return statement is always compatible with another.
>         ast.Return: lambda node: "(easy)",
>         # Calling these never compatible is wrong. Calling them
>         # always compatible will give lots of false positives.
>         ast.Expr: lambda node: "(maybe)",
>         # These ones are never compatible, so return some
>         # object that's never equal to anything.
>         ast.Import: lambda node: float("nan"),
>         ast.ImportFrom: lambda node: float("nan"),
>         ast.Pass: lambda node: float("nan"),
>         ast.Raise: lambda node: float("nan"),
>         ast.If: lambda node: float("nan"),
>     }
>
> vs (my proposal):
>
>     with key from ast:
>         if Assign:
>             return ' '.join(dump(t) for t in node.targets)
>         elif AugAssign:
>             # Same target and same operator.
>             return dump(node.target) + dump(node.op) + "="
>         elif Return:
>             # A return statement is always compatible with another.
>             return "(easy)"
>         elif Expr:
>             # Calling these never compatible is wrong. Calling them
>             # always compatible will give lots of false positives.
>             return "(maybe)"
>         else:
>             # These ones are never compatible, so return some
>             # object that's never equal to anything.
>             return float("nan")
>
> Which do *you* find more readable?

Your proposal requires that I wrap the whole thing up in a function,
or else pass the lookup key to my function every time and switch on
it, instead of getting back a single function once. So you haven't
truly matched the functionality, which means it's hard to compare
readability - I'd have to also look at how readable the call site is,
and that's definitely going to be penalized. Remember, I pointed out
that the function gets called more than once - once on the special
case and then once in a loop.

Plus, how do you implement mutability? The else clause needs to do a
one-off print to stderr, so either the dispatch table needs to be
changed, or the else clause needs some other system of keeping track
of its previously-seen list. Additionally, I have another script that
actually monkey-patches the Expr case out, simply by changing the
dict. It works just fine, because, again, the dict is mutable. To do
that with a switch statement, I'd need to put an explicit 'if' into
there. Show me that version and let's see how readable it is.

There may be a case (pun intended) for adding a switch block to
Python, but this isn't a strong supporting instance.

ChrisA