I would like to propose a change to type guards, in order to make using them in code more readable. However, I am unsure how achievable this added functionality would be:
# Specification
I would like to have type guards as readable as human text. Currently we use type guards in the following manner:
```
def is_list_of_str(value: list[object]) -> TypeGuard[list[str]]:
return all(isinstance(x, str) for x in value)
```
However, this whole TypeGuard with nested syntax isn't really that readable, is it? In TypeScript, I think this problem was solved in a more beautiful way. I would like to propose to use the same syntax as TypeScript for user defined type guards:
```
def is_list_of_str(value: list[object]) -> value is list[str]:
return all(isinstance(x, str) for x in value)
```
Since this might not be achievable, because value is not defined at the moment of statically typing, we might want to do something along the lines of either:
```
def is_list_of_str(value: list[object]) -> "value" is list[str]:
return all(isinstance(x, str) for x in value)
def is_list_of_str(value: list[object]) -> "value is list[str]":
return all(isinstance(x, str) for x in value)
```
My preference would be the first one of the above examples, since this combines the readability with the current way used to type hint variables that may be defined later.
Please let me know whether or not you think this is worth pursuing, as well as your general thoughts on the subject.
- Job