I don't much like allowing `(str, int, int -> int)` either, agree that it would seem ambiguous. I guess there's another open question of whether to require parentheses for one-argument functions, e.g. can you write `Callable[[int], int]` as `int -> int` like an ML-style language, or do we insist on `(int) -> int`. My preference would actually be to require the parentheses in order to preserve the "def-like" syntax, my guess is that `int -> int` would be a lot more likely to confuse newcomers. Bare `->` with right-associativity are a natural fit for languages with currying, but in python it seems less clear. If we require arguments in parentheses then questions about associativity and precedence mostly disappear: - `((int) -> bool) -> float` would be the only way to indicate a function that takes an `(int) -> bool` and returns a `float` - `(int) -> ((int) -> float)` would indicate a function taking an `int` and returning a `(bool) -> float` - if we decide not to mandate parentheses around return types, then we'd get a kind of right-associativity where this could also be written `(int) -> (bool) -> float`, which would be unambiguous