late

Late binding for Python default arguments

What is it?

late provides decorators and functions to work around the issues that early binding of default values produces in Python.

This is not intuitive for newcomers to Python, but it's something that everyone learns quickly:

>>> def f(x=[]):
...     x.append(1)
...     return x
...
>>> f()
[1]
>>> f()
[1, 1]
>>> f()
[1, 1, 1]

The behavior in Python is that the same [] initializer is passed on every function invocation.

The coding pattern to work around the above is to use None as the initializer, and check for the parameter value at the start of the function code:

>>> def f(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     return x
...
>>> f()
[1]
>>> f()
[1]
>>> f()
[1]

It's ugly, but it works.

Now comes the orther ugly part. When using type annotations, the above function must be declared in away that type checkers do not complain about using None as the default value:

>>> def f(x: list[Any] | None = None) -> list[Any]:

late provides a way to solve the above ugliness with some decorator magic. This is how the new code would look with some magic:

from late import latebinding, __


@latebinding
def f(x: list[Any] = __([])) -> list[Any]:
    x.append(1)
    return x

About name choice

The names of what late exports are chosen to be explicit where it matters, and to not get in the way of the vissuals of a declaration. In particular, __() was chose to intefere the least possible with reading a function declaration (late() is another name for it).

At any rate, late is so simple and so small that you can apply any changes you like and use it as another part of your code instead of installing it as a library.

License

late is under the GNU GENERAL PUBLIC LICENSE Version 3, as reades in the [LICENSE)(LICENSE) file.