
On 29 Nov 2021, at 23:56, Barry Warsaw wrote:
[...]
(not that you're not allowed to use for anything else, of course you are, but that other uses won;t be taken into account when designing the new interface)
But I have never seen that clearly stated anywhere. The closest is from PEP 563, where it says:
""" With this in mind, uses for annotations incompatible with the aforementioned PEPs should be considered deprecated. """
Which pretty much makes the point, but it's a bit subtle -- what does "incompatible' mean?
You make a good point. I agree that while all the signs are there for “annotations are for typing”, this has never been explicitly or sufficiently codified, and I’ve been proposing that Someone write a PEP that makes this an official pronouncement. That someone may very well be a person on the SC, but given the timing of elections, it’s likely to fall to the next SC, if they still agree with that position! :-D
My recollection of the history of annotations falls somewhere between Greg’s and Guido’s. Annotations as a feature were inspired by the typing use case (with no decision at the time whether those were to be static or runtime checks), but at the same time allowing for experimentation for other use cases. Over time, annotations-for-typing clearly won the mindset and became the predominant use case. Personally, I was strongly against type annotations because of my experience in other languages, but over time I was also won over. From library documentation, to complex code bases, to the transient nature of contributors, type annotations are pretty compelling, and most (but not all) of my worries really didn’t come to fruition.
We can lament the non-typing use of annotations, but I think that horse is out of the barn and I don’t know how you would resolve conflicts of use for typing and non-typing annotations. It’s been a slow boil, with no definitive pronouncement, and that needs to be fixed, but I think it's just acknowledging reality. That’s my personal opinion.
But isn't that the reason why we have `typing.Annotated`, so that annotations used for typing and annotations used for other purposes can coexist? An annotation used for typing only is: ```
def f(x: int): ... return x ... f.__annotations__['x'] <class 'int'>
An annotation used for something else is:
def f(x: 'something not typing related'): ... return x ... f.__annotations__['x'] 'something not typing related'
`typing.Annotated` gives us both:
from typing import * def f(x: Annotated[int, 'something not typing related']): ... return x ... f.__annotations__['x'].__args__[0] <class 'int'> f.__annotations__['x'].__metadata__[0] 'something not typing related'
Granted, for someone who only wants to use annotations for their own
purpose, digging out the original not typing related stuff from
`typing.Annotated` is more work, but doable.
Or am I missing something here?
> [...]
Servus,
Walter