Back in early 2016 there was an idea submitted[1] by Joseph Martinot-Lagarde in
regard to anonymous namedtuples. The crux of the submission was the idea of
instantiating a namedtuple using only Python's generic tuple syntax plus
keyword arguments. At the time, the major rebuttal against this idea however
was that, since kwargs are an unordered collection, it would be non-trivial to
figure out a proper convention for mapping an unordered collection onto an
ordered one.
Times have changed however, and with python3.6/3.7 we now have the guarantee
that dictionaries are insertion ordered. This means that by extension keyword
arguments are also ordered, and thus the major point of contest against
anonymous namedtuples is now moot. And as such I would like to once again
suggest anonymous namedtuples as a potential PEP.
Proposal
=======
The proposal ultimately is the same as before:
```
my_point = (x=12, y=16)
# (x=12, y=16)
my_point[0]
# 12
```
where kwargs can be passed to a tuple's instantiation [either via tuple() or
just ()], and these tuples would have all the same properties of a namedtuple.
A basic, pure-python implementation is actually quite trivial now given that
kwargs are ordered. Observe:
```
def atuple(**kwargs):
signature = " ".join(kwargs)
_type = atuple.__dict__.get(signature)
if not _type:
_type = namedtuple(atuple.__name__, signature)
atuple.__dict__[signature] = _type
return _type(**kwargs)
```
This has none of the problems suggested in the previous rebuttal.
anonymous tuples of incorrect ordering raise the assertion error, as expected:
```
>>> assert atuple(x=12, y=16) == atuple(y=16, x=12)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AssertionError
```
...and by extension it preserves the users's specified ordering as given by
**kwargs.
```
>>> pt = atuple(r=3, theta=0.5, phi=0.25)
>>> pt
atuple(r=3, theta=0.5, phi=0.25)
```
Given that this implementation caches the type by the keyword signature,
anonymous tuples of the same signature are recognized as the same type.
However, given differing values, they are not equal.
```
>>> type(atuple(x=1,y=2)) == type(atuple(x=1,y=2))
True
>>> atuple(x=1,y=2) == atuple(x=1,y=3)
False
```
This allows us to provide positional arguments to the construct, just like
regular namedtuples, and passing a mismatch throws an error as expected.
```
>>> pt = atuple(x=12, y=16)
>>> pt
atuple(x=12, y=16)
>>> type(pt)(1,2)
atuple(x=1, y=2)
>>> type(pt)(1,2,3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: atuple.__new__() takes 3 positional arguments but 4 were given
```
As we can see, the introduction of insertion-ordered dictionaries solves all of
the issues previously raised with regard to anonymous namedtuples.
References:
[1] https://mail.python.org/pipermail/python-ideas/2016-April/039857.html
_______________________________________________
Python-ideas mailing list -- [email protected]
To unsubscribe send an email to [email protected]
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at
https://mail.python.org/archives/list/[email protected]/message/EUJTGE2VIHHMNJN574L5BEAS7ROSTYZL/
Code of Conduct: http://python.org/psf/codeofconduct/
