I’m a little busy recently, so I’ll reply to as much as I can now and reply to
the rest later.
Scratch the stuff I said about scope. Backtick expressions should inherit the
scope normally like any other nested function.
> That's different behaviour from regular functions, where names are only
> resolved when the function is called.
What benefits are there to the late name lookup of normal functions? I’m
looking to have backtick expressions raise early, not late.
We can relax the names to be optional if a ternary expression is used within
the backtick expression.
I realized that the behavior of Backtick Expressions can be silently affected
by global variables. Example:
x = 1
def increment_each(l):
return map(`x+1`, l)
## Explicit expression, implicit usage
Explicit backtick expressions are ones that, for all parameters that the
created function produces, it uses a caret before the name of the parameter.
The other names must exist when the backtick expression is evaluated. Example:
parameter = 0
is_integer = `int(^parameter) == ^parameter` # arity: 1 despite the global
definition
self = 'James'
str = `^self.__class__.__str__(^self)` # arity: 1 despite the global definition
str(type(lambda: 1)) # use our custom str function on the function type;
output: <type 'function' at 0x84910>
## Implicitly Created Backtick Expression
Implicit baktick expressions, ones that mention undefined parameters without
using the caret mark are generally discouraged. However they create
UncastBacktickExpression, which must be cast using the .to_safe(*names) method
to be used, which takes in a list of parameter names and outputs a normal
backtick expression.
Even if the variable is defined on a global level, it can be explicitly
overridden in to_safe.
Example 1
`x+1`.to_safe('x')(1) # output: 2
Example 2
x = 0
`x+1`.to_safe('x')(1) # output: 2
If a backtick expression has no unspecified names and has no carets, it is an
implicit backtick expression.
This allows developers to safely omit the ^ when the code that is using the
resulting backtick expression is aware of the parameters to be used, given that
it's obvious to the developer which names are parameters.
> On Jan 21, 2019, at 1:56 AM, Steven D'Aprano <[email protected]> wrote:
>
> That's different behaviour from regular functions, where names are only
> resolved when the function is called.
_______________________________________________
Python-ideas mailing list
[email protected]
https://mail.python.org/mailman/listinfo/python-ideas
Code of Conduct: http://python.org/psf/codeofconduct/
