I like the idea of a less-cumbersome way to annotate callables. Did you consider using parentheses (i.e. tuple notation) rather than square brackets? Parentheses would more closely mirror the punctuation of a function declaration, so it might be more natural to most Python developers. ```python (ParamType1, ParamType2, ParamType3) -> ReturnType ``` TypeScript uses a similar notation for callable types, except that it replaces `->` with `=>`, and it requires the names of parameters to be specified as well, as in `(a: ParamType1, b: ParamType2) => ReturnType`. Including the names of parameters would allow for variadic parameters and keyword-only separators, as in `(a: int, *args: Any, *, b: str, **kwargs: Any) -> float`. One thing to consider is how to express `Callable[..., ReturnType]`. Would that be `(...) -> ReturnType`? Another consideration is that the combination of this proposal and PEP 604 would produce ambiguities. For example, what type is `(int) -> str | float`? Is that a union of a callable and a float, or is it a callable that returns a union? We'd need to decide on relative precedence of the `|` and `->` operators. (I'd recommend that `->` bind more tightly than `|`). We'd also need to add support for parentheses in type expressions to override the default precedence: `((int) -> str) | float` vs `(int -> str) -> (str | float)`. -- Eric Traut Contributor to pyright and pylance Microsoft Corp.