Path: csiph.com!v102.xanadu-bbs.net!xanadu-bbs.net!news.albasani.net!rt.uk.eu.org!newsfeed.xs4all.nl!newsfeed4a.news.xs4all.nl!xs4all!post.news.xs4all.nl!not-for-mail
MIME-Version: 1.0
In-Reply-To: <op.xc7f5vuf5079vu@gnudebeest>
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> <mailman.8377.1395456097.18130.python-list@python.org> <dcd72881-7ee2-4bc3-90ab-7912b4bea05b@googlegroups.com> <mailman.8382.1395463877.18130.python-list@python.org> <9edb4ea0-5faf-4369-8021-48afa9800a34@googlegroups.com> <op.xc5fr8pn5079vu@gnudebeest> <mailman.8412.1395542839.18130.python-list@python.org> <op.xc7f5vuf5079vu@gnudebeest>
Date: Mon, 24 Mar 2014 14:27:32 +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.8434.1395631654.18130.python-list@python.org>
Lines: 48
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: csiph.com comp.lang.python:68842

On Mon, Mar 24, 2014 at 1:35 PM, Rhodri James <rhodri@wildebst.org.uk> wrote:
>> Would you not consider this to be declarative?
>>
>>    x = [1, 2, 3]
>
>
> I'm not sure I would.  I look at that line of code and think of it as
> "Create a list...", very much in an imperative manner.  Then again, compared
> with C structs and typedefs and actual honest-to-God type declarations,
> there's precious little in Python I would consider truly declarative.

I'm in the declarative group here. Yes, it has to be implemented as
creating a list and adding three elements to it, but conceptually, it
means "Bind x to a new list with these elements". And as long as
that's the end result, I don't care how it's done; the interpreter's
most welcome to have a "template list" that it copies, or maybe a
literal tuple that gets passed to the list() constructor, or
whatever's most efficient.

It gets a bit messier when there's stuff with side effects, though.
This has to be a bit more imperative:

x = [foo(y), bar(y), quux(y)]

That means "Call foo, bar, and quux, in that order, each with y as an
argument, and bind x to a new list with their return values". And if
Python had a simple notation for calling a series of functions, that
could be written something like this:

funcs = [foo, bar, quux]
x = funcs(y)

which is looking more declarative again. It's now "Take this list of
functions and call them all, and bind x to a list of their return
values". (This could be done, with a callable subclass of list. Call
it a sort of "implicit map" if you like.) Python doesn't have that
syntax, but it does have this:

x = [f(y) for f in funcs]

and I'd say that's reasonably declarative; it should be read like the
previous one: "Take this list of funcs, call each one, and bind x to a
list of their return values". And I could imagine a
parallel-processing version of a list comp that functions like
multiprocessing.Pool.map() and doesn't promise order, which would
*definitely* be declarative.

ChrisA