This would require adding a special case to the type system. We generally only add special cases for things that are very common and useful, and I'm not sure "functions returning themselves" fall in that category. What is the use case?

That's fair. I don't think this is a critical missing feature, but I was wondering whether the readability and expressiveness benefits could justify it.

Right now, recursive callable aliases work, but they feel indirect for the specific case of a function returning itself:

from typing import TypeAlias
from collections.abc import Callable

SelfFunc: TypeAlias = Callable[..., "SelfFunc"]

whereas -> Self directly communicates intent.

Potential use cases I thought of were:

• self-returning decorators/callback systems
• recursive functional APIs
• parser combinators or REPL-style command loops

Though I agree these may be too niche to justify special handling in the type system.

I didn’t think about using a protocol with Self like that.

What I was mainly thinking about was annotating the function itself, especially for nested/self-referential functions like:

def outer():
    def inner() -> ???:
        return inner

The protocol approach does work, but it feels a little verbose for something as simple as “this function returns itself”.

I do get the concern about adding another special case to the type system though, especially for something pretty niche.