On 5/21/06, Marcin 'Qrczak' Kowalczyk <[EMAIL PROTECTED]> wrote:
> Nick Coghlan <[EMAIL PROTECTED]> writes:
>
> > Assume the following is true for a type annotation system:
> > (T,) is equivalent to tuple[T]
> > (T1, T2) is equivalent to tuple[T1, T2]
> > (T1, T2, T3) is equivalent to tuple[T1, T2, T3]
>
> This is ambiguous: tuple[T1, T2] is the same as tuple[(T1, T2)],
> i.e. it's a 1-tuple containing a 2-tuple.
tuple[T1, T2] a 2-tuple with element 1 of type T1 and element 2 of
type T2. A 1-tuple containing a 2-tuple would be tuple[tuple[T1, T2]].
However, we still need to decide what happens in the case of
tuple[(T1, T2)]. Is the (T1, T2) coerced to tuple[T1, T2]?
My vote is "yes", but I don't have a full idea of how this coercion
would work. One solution would be to let the metaclass (the one that
catches the __getitem__ call on, e.g., tuple) automatically convert
non-annotations (using a to-be-decided test for annotation-ness) to
annotations. Something like this on the metaclass might do the trick
(based on Guido's metaclass sketch):
def __getitem__(self, arg):
newcls = self.__class__(self.__name__, (self,), {})
newcls.T = arg if is_annotation(arg) else type(arg)[arg]
return newcls
Collin Winter
_______________________________________________
Python-3000 mailing list
[email protected]
http://mail.python.org/mailman/listinfo/python-3000
Unsubscribe:
http://mail.python.org/mailman/options/python-3000/archive%40mail-archive.com
