[Python-ideas] Delayed Execution via Keyword

Abe Dillon abedillon at gmail.com
Thu Mar 2 21:10:23 EST 2017 

>
> without special casing iteration how do you know that `x1 = next(xs)`
> depends on the value of `x0`?

`x1 = next(xs)` doesn't depend on the value of `x0`, it depends on the
state of xs. In order to evaluate `next(xs)` you have to jump into the
function call and evaluate the relevant expressions within, which will,
presumably, mean evaluating the value of some place-holder variable or
something, which will trigger evaluation of preceding, pending expressions
that modify the value of that place-holder variable, which includes `x0 =
next(xs)`.

You do have a point, though; if the pending-execution graph has to be fine
enough scale to capture all that, then it's a dubious claim that juggling
such a construct would save any time over simply executing the code as you
go. This, I believe, goes beyond iterators and gets at the heart of what
Josh said:

What you really do want is functional purity, which is a different concept
> and one that python as a language can't easily provide no matter what.


`next` is not a pure function, because it has side-effects: it changes
state variables. Even if those side-effects can be tracked by the
interpreter, they present a challenge. In the example:
>>> log.warning(expensive_function())

Where we want to avoid executing expensive_function(). It's likely that the
function iterates over some large amount of data. According to the `x1 =
next(xs)` example, that means building a huge pending-execution graph in
case that function does need to be evaluated, so you can track the iterator
state changes all the way back to the first iteration before executing.

Perhaps there's some clever trick I'm not thinking of to keep the graph
small and only expand it as needed. I don't know. Maybe, like Joshua
Morton's JIT example, you could automatically identify loop patterns and
collapse them somehow. I guess special casing iteration would help with
that, though it's difficult to see what that would look like.



On Thu, Mar 2, 2017 at 7:30 PM, Joseph Jevnik <joejev at gmail.com> wrote:

> without special casing iteration how do you know that `x1 = next(xs)`
> depends on the value of `x0`? If you assume every operation depends on
> every other operation then you have implemented an eager evaluation model.
>
> On Thu, Mar 2, 2017 at 8:26 PM, Abe Dillon <abedillon at gmail.com> wrote:
>
>> I don't think you have to make a special case for iteration.
>>
>> When the interpreter hits:
>> >>> print(x1)
>>
>> print falls under I/O, so it forces evaluation of x1, so we back-track to
>> where x1 is evaluated:
>> >>> x1 = next(xs)
>>
>> And in the next call, we find that we must evaluate the state of the
>> iterator, so we have to back-track to:
>> >>> x0 = next(xs)
>>
>> Evaluate that, then move forward.
>>
>> You essentially keep a graph of pending/unevaluated expressions linked by
>> their dependencies and evaluate branches of the graph as needed. You need
>> to evaluate state to navigate conditional branches, and whenever state is
>> passed outside of the interpreter's scope (like I/O or multi-threading). I
>> think problems might crop up in parts of the language that are pure c-code.
>> For instance; I don't know if the state variables in a list iterator are
>> actually visible to the Interpreter or if it's implemented in C that is
>> inscrutable to the interpreter.
>>
>>
>> On Mar 2, 2017 5:54 PM, "Joseph Jevnik" <joejev at gmail.com> wrote:
>>
>> Other things that scrutinize an expression are iteration or branching
>> (with the current evaluation model). If `xs` is a thunk, then `for x in xs`
>> must scrutinize `xs`. At first this doesn't seem required; however, in
>> general `next` imposes a data dependency on the next call to `next`. For
>> example:
>>
>> x0 = next(xs)
>> x1 = next(xs)
>>
>> print(x1)
>> print(x0)
>>
>> If `next` doesn't force computation then evaluating `x1` before `x0` will
>> bind `x1` to `xs[0]` which is not what the eager version of the code does.
>>
>> To preserve the current semantics of the language you cannot defer
>> arbitrary expressions because they may have observable side-effects.
>> Automatically translating would require knowing ahead of time if a function
>> can have observable side effects, but that is not possible in Python.
>> Because it is impossible to tell in the general case, we must rely on the
>> user to tell us when it is safe to defer an expression.
>>
>> On Thu, Mar 2, 2017 at 6:42 PM, Abe Dillon <abedillon at gmail.com> wrote:
>>
>>> I'm going to repeat here what I posted in the thread on lazy imports.
>>> If it's possible for the interpreter to determine when it needs to force
>>> evaluation of a lazy expression or statement, then why not use them
>>> everywhere? If that's the case, then why not make everything lazy by
>>> default? Why not make it a service of the language to lazify your code
>>> (analogous to garbage collection) so a human doesn't have to worry about
>>> screwing it up?
>>>
>>> There are, AFAIK, three things that *must* force evaluation of lazy
>>> expressions or statements:
>>>
>>> 1) Before the GIL is released, all pending lazy code must be evaluated
>>> since the current thread can't know what variables another thread will try
>>> to access (unless there's a way to explicitly label variables as "shared",
>>> then it will only force evaluation of those).
>>>
>>> 2) Branching statements force evaluation of anything required to
>>> evaluate the conditional clause.
>>>
>>> 3) I/O forces evaluation of any involved lazy expressions.
>>>
>>>
>>> On Mon, Feb 20, 2017 at 7:07 PM, Joshua Morton <
>>> joshua.morton13 at gmail.com> wrote:
>>>
>>>> This comes from a bit of a misunderstanding of how an interpreter
>>>> figures out what needs to be compiled. Most (all?) JIT compilers run code
>>>> in an interpreted manner, and then compile subsections down to efficient
>>>> machine code when they notice that the same code path is taken repeatedly,
>>>> so in pypy something like
>>>>
>>>>     x = 0
>>>>     for i in range(100000):
>>>>         x += 1
>>>>
>>>> would, get, after 10-20 runs through the loop, turned into assembly
>>>> that looked like what you'd write in pure C, instead of the very
>>>> indirection and pointer heavy code that such a loop would be if you could
>>>> take it and convert it to cpython actually executes, for example. So the
>>>> "hot" code is still run.
>>>>
>>>> All that said, this is a bit of an off topic discussion and probably
>>>> shouldn't be on list.
>>>>
>>>> What you really do want is functional purity, which is a different
>>>> concept and one that python as a language can't easily provide no matter
>>>> what.
>>>>
>>>> --Josh
>>>>
>>>> On Mon, Feb 20, 2017 at 7:53 PM Abe Dillon <abedillon at gmail.com> wrote:
>>>>
>>>>> On Fri, Feb 17, 2017, Steven D'Aprano wrote:
>>>>>
>>>>> JIT compilation delays *compiling* the code to run-time. This is a
>>>>> proposal for delaying *running* the code until such time as some other
>>>>> piece of code actually needs the result.
>>>>>
>>>>>
>>>>> My thought was that if a compiler is capable of determining what needs
>>>>> to be compiled just in time, then an interpreter might be able to determine
>>>>> what expressions need to be evaluated just when their results are actually
>>>>> used.
>>>>>
>>>>> So if you had code that looked like:
>>>>>
>>>>> >>> log.debug("data: %s", expensive())
>>>>>
>>>>> The interpreter could skip evaluating the expensive function if the
>>>>> result is never used. It would only evaluate it "just in time". This would
>>>>> almost certainly require just in time compilation as well, otherwise the
>>>>> byte code that calls the "log.debug" function would be unaware of the byte
>>>>> code that implements the function.
>>>>>
>>>>> This is probably a pipe-dream, though; because the interpreter would
>>>>> have to be aware of side effects.
>>>>>
>>>>>
>>>>>
>>>>> On Mon, Feb 20, 2017 at 5:18 AM, <tritium-list at sdamon.com> wrote:
>>>>>
>>>>>
>>>>>
>>>>> > -----Original Message-----
>>>>> > From: Python-ideas [mailto:python-ideas-bounces+tritium-
>>>>> > list=sdamon.com at python.org] On Behalf Of Michel Desmoulin
>>>>> > Sent: Monday, February 20, 2017 3:30 AM
>>>>> > To: python-ideas at python.org
>>>>> > Subject: Re: [Python-ideas] Delayed Execution via Keyword
>>>>> >
>>>>> > I wrote a blog post about this, and someone asked me if it meant
>>>>> > allowing lazy imports to make optional imports easier.
>>>>> >
>>>>> > Someting like:
>>>>> >
>>>>> > lazy import foo
>>>>> > lazy from foo import bar
>>>>> >
>>>>> > So now if I don't use the imports, the module is not loaded, which
>>>>> could
>>>>> > also significantly speed up applications starting time with a lot of
>>>>> > imports.
>>>>>
>>>>> Would that not also make a failure to import an error at the time of
>>>>> executing the imported piece of code rather than at the place of
>>>>> import?
>>>>> And how would optional imports work if they are not loaded until use?
>>>>> Right
>>>>> now, optional imports are done by wrapping the import statement in a
>>>>> try/except, would you not need to do that handling everywhere the
>>>>> imported
>>>>> object is used instead?
>>>>>
>>>>> (I haven't been following the entire thread, and I don't know if this
>>>>> is a
>>>>> forest/tress argument)
>>>>>
>>>>> > _______________________________________________
>>>>> > Python-ideas mailing list
>>>>> > Python-ideas at python.org
>>>>> > https://mail.python.org/mailman/listinfo/python-ideas
>>>>> > Code of Conduct: http://python.org/psf/codeofconduct/
>>>>>
>>>>> _______________________________________________
>>>>> Python-ideas mailing list
>>>>> Python-ideas at python.org
>>>>> https://mail.python.org/mailman/listinfo/python-ideas
>>>>> Code of Conduct: http://python.org/psf/codeofconduct/
>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> Python-ideas mailing list
>>>>> Python-ideas at python.org
>>>>> https://mail.python.org/mailman/listinfo/python-ideas
>>>>> Code of Conduct: http://python.org/psf/codeofconduct/
>>>>
>>>>
>>>
>>> _______________________________________________
>>> Python-ideas mailing list
>>> Python-ideas at python.org
>>> https://mail.python.org/mailman/listinfo/python-ideas
>>> Code of Conduct: http://python.org/psf/codeofconduct/
>>>
>>
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-ideas/attachments/20170302/90ab576a/attachment-0001.html>

More information about the Python-ideas mailing list