Path: csiph.com!newsfeed.hal-mli.net!feeder3.hal-mli.net!newsfeed.hal-mli.net!feeder1.hal-mli.net!newsfeed.xs4all.nl!newsfeed4a.news.xs4all.nl!xs4all!post.news.xs4all.nl!not-for-mail
MIME-Version: 1.0
In-Reply-To: <532d15e8$0$29994$c3e8da3$5496439d@news.astraweb.com>
References: <9daf0806-02de-4447-964c-c8f8953c23e5@googlegroups.com> <10101874-2995-4acd-9851-989603f052e3@googlegroups.com> <bd158c7b-5511-472c-bce3-cc7b6b7747f6@googlegroups.com> <e2b2b9d5-56bd-4455-b8c3-205000d9acb3@googlegroups.com> <mailman.8369.1395437459.18130.python-list@python.org> <a0403642-c384-4623-bbfd-77c48285ec96@googlegroups.com> <532d15e8$0$29994$c3e8da3$5496439d@news.astraweb.com>
Date: Sat, 22 Mar 2014 16:05:29 +1100
Subject: Re: Explanation of this Python language feature? [x for x in x for x in x] (to flatten a nested list)
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.8383.1395464733.18130.python-list@python.org>
Lines: 47
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: csiph.com comp.lang.python:68748

On Sat, Mar 22, 2014 at 3:47 PM, Steven D'Aprano
<steve+comp.lang.python@pearwood.info> wrote:
> Now I'm not sure precisely how Haskell implements this trick, but it
> suggests to me that it creates a different closure each time around the
> loop of the comprehension. That could end up being very expensive.

It needn't be terribly expensive, if you make a "scope stack" or
"scope chain". Imagine, if you will, a system of scopes like this:

current_scope = None
class Scope:
    def __init__(self, *a, **kw):
        self.names = dict(*a, **kw)
        global current_scope
        self.parent = current_scope
        current_scope = self
    def __getitem__(self, name):
        try:
            return self.names[name]
        except KeyError:
            if self.parent is None: raise
            return self.parent[name]
    def __setitem__(self, name, value):
        self.names[name] = value
def exit_scope():
    global current_scope
    current_scope = current_scope.parent

Creating a new scope would be fairly cheap (and a lot more so if this
were implemented in C without the object overhead, of course). Lookups
would scan up through a series of namespaces, same as they currently
do (local, module, builtins), there'd just be more of them. And the
compiler could be smart enough to skip creating a scope if there are
no assignments. There'd need to be some handling in there for the
'nonlocal' keyword, but my expectation is that 'global' is handled by
retaining a reference to the current_scope at module level, and
starting the search there for a LOAD_GLOBAL.

Each iteration of the loop could begin with Scope() and end with
exit_scope(), and there you are, each iteration in its own closable
scope.

I'm not saying it would be a good thing to do - and it'd be a bad fit
for Python, I think, as I said in my other post - but it could be
done.

ChrisA