I would like to briefly share my thoughts on non-standard evaluation (NSE),
why this is useful, and how, potentially, it can be added to Python. In
most languages, functions have access only to the *value* of their
arguments, and not to the expressions that yielded those values. However,
sometimes it is useful to have access to the expressions as well. For
example, let plot(x, y, ...) be a function that draws the scatter plot of y
against x and adds labels for the x- and y-axes. Currently, there is no way
to distinguish plot(x, *z*, ...) from plot(x, *y*, ...) from within the
function. As such, one needs to pass the names of the variables to the plot
function to be used as the axes' labels. Using NSE, though, the function
can look at the expressions in the method call and use those as the default
value for labels. In R, this idea is used widely to make the syntax simpler.
In the following, I sketch how I think this can be implemented:
1. Let BoundExpression be a class containing an ast.Expression as well
as locals and globals dictionaries. BoundExpression can also have an eval
method that evaluates its expression using its locals and globals
2. Let `x` be the short form for BoundExpression("x", locals(),
globals()). Then, the plot function can be implemented in a way that
plot(`x`, `y`) draws scatter plot of x and y *and also,* labels the axes
correctly. No need to provide labels explicitly anymore.
3. A more challenging idea is to let developers decide whether their
functions need NSE or not. For example, when a function is defined as def
f(`x`), for any method call like f(x), the first argument should be wrapped
with a BoundExpression instance.
I would appreciate any feedback on these ideas.