
What about creating a new syntax for annotating metadata? For example, `type_hint :: metadata` could be equivalent to `Annotated[type_hint, "metadata"]`, and if we wanted type guards to look like TypeScript they could look like this: ``` def is_str_list(val: List[object]) -> bool :: is List[str]: ``` This might not be the best syntax, it's just one idea, but my point is that achieving all of these goals simultaneously seems quite doable: - Showing the actual return type - Showing metadata - Putting arbitrary non-Python syntax in metadata - Retrieving the type part of the annotation at runtime as an actual type value, not a string - Retrieving the metadata at runtime as a string - Avoiding the cumbersome `Annotated[]` syntax In addition, if someone wants annotations only for other metadata and not for types at all [1] then it's easy to just omit the type part, e.g ``` def foo(bar :: bar metadata) :: foo metadata: ``` Again, the `::` may be a bad way to do this, but the same principle of non-type-meta-only-annotations could probably be applied to other similar syntax proposals. I'm sure I'm not the first to suggest something like this, but I couldn't see anything in PEP 593. I was particularly expecting something like "New syntax" as a section under "Rejected ideas". The closest thing is "Using (Type, Ann1, Ann2, ...) instead of Annotated[Type, Ann1, Ann2, ...]" which felt a bit weak. [1] e.g. as I have done in https://github.com/alexmojaki/friendly_states which looks lovely but completely breaks mypy