Another (pretty wild) idea that I have not seen before is putting the type definitions after the class/function definition. ```python class C<T, S>: def foo<R>(self) -> R: pass ``` would become something like ```python class C where T=TypeVar(), S=TypeVar(): def foo(self) -> R where R=TypeVar(bound=int): pass ``` This avoids bracket hell and is a bit more wordy (which is not a bad thing in a language like python that prefers keywords over punctuation). This also looks good with longer type definitions if they can be put on a new line: ```python def example(a: A, b: B, c: C) -> D where A=TypeVar(bound=int), B=TypeVar(bound=float), C=TypeVar(bound=str), D=TypeVar(bound=str): pass ``` instead of `where T=TypeVar()` it could also be spelled as `with TypeVar() as T` which I'd actually prefer from an aesthetic point of view, but might confuse people due to `with` being used in a totally different context (pun intended) already.