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.

[RBerga06]

Would a callback protocol do the trick?

from typing import Protocol, Self

class F(Protocol):
    def __call__(self, /) -> Self: ...

def factory() -> F:
    def f(): return f
    return f

[Natuworkguy]

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.