Supporting Self for Free Functions?

[Natuworkguy]

Currently, typing.Self only works in class contexts.

I noticed that typing a function that returns itself requires recursive callable aliases, for example:

from typing import TypeAlias
from collections.abc import Callable

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

def f() -> SelfFunc:
    return f

Would it make sense to allow:

from typing import Self

def f() -> Self:
    return f

for standalone functions?

This seems more readable and directly expresses intent, but I’m not sure whether there are ambiguity or implementation issues with extending Self beyond classes/methods.

Are there reasons this should or should not be supported?

[JelleZijlstra]

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?

[Natuworkguy]

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.