[Python-ideas] A partial (wacky?) alternative to assignment expressions
mertz at gnosis.cx
Mon May 14 20:46:42 EDT 2018
The time machine is used again! We HAVE a spelling: @functions.lru_cache()
The problem is that there's still a time/space trade-off. If you might call
a (pure) function with millions of different values, you likely don't want
to cache them all. The current spelling makes this configurable, but
there's no universal right answer.
On Mon, May 14, 2018, 8:36 PM Steven D'Aprano <steve at pearwood.info> wrote:
> I'm hoping that the arguments for assignment expressions will be over by
> Christmas *wink* so as a partial (and hopefully less controversial)
> alternative, what do people think of the idea of flagging certain
> expressions as "pure functions" so the compiler can automatically cache
> results from it?
> Let me explain: one of the use-cases for assignment expressions is to
> reduce repetition of code which may be expensive. A toy example:
> func(arg) + func(arg)*2 + func(arg)**2
> If func() is a pure function with no side-effects, that is three times
> as costly as it ought to be:
> (f := func(arg)) + f*2 + f**2
> Functional languages like Haskell can and do make this optimization all
> the time (or so I am lead to believe), because the compiler knows that
> func must be a pure, side-effect-free function. But the Python
> interpreter cannot do this optimization for us, because it has no way of
> knowing whether func() is a pure function.
> Now for the wacky idea: suppose we could tell the interpreter to cache
> the result of some sub-expression, and re-use it within the current
> expression? That would satisfy one use-case for assignment operators,
> and perhaps weaken the need for := operator.
> Good idea? Dumb idea?
> Good idea, but you want the assignment operator regardless?
> I don't have a suggestion for syntax yet, so I'm going to make up syntax
> which is *clearly and obviously rubbish*, a mere placeholder, so don't
> bother telling me all the myriad ways it sucks. I know it sucks, that's
> deliberate. Please focus on the *concept*, not the syntax.
> We would need to flag which expression can be cached because it is PURE,
> and tag how far the CACHE operates over:
> <BEGIN CACHE>
> <END PURE>
> + func(arg)*2 + func(arg)**2
> <END CACHE>
> This would tell the compiler to only evaluate the sub-expression
> "func(arg)" once, cache the result, and re-use it each other time it
> sees that same sub-expression within the surrounding expression.
> To be clear: it doesn't matter whether or not the sub-expression
> actually is pure. And it doesn't have to be a function call: it could be
> anything legal in an expression.
> If we had this, with appropriately awesome syntax, would that negate the
> usefulness of assignment expresions in your mind?
> Python-ideas mailing list
> Python-ideas at python.org
> Code of Conduct: http://python.org/psf/codeofconduct/
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Python-ideas