returning a Final value from a function

[Josverl]

For MicroPython typing with pyright I would like the return type of the built-in method const to be Final.
Note: const is not really a function, see micropython.const

When I try adding that to __builtins__.pyi I get either:

• "Final" is not allowed in this context (return type)
• Function "const" cannot be marked final because it it not a method (decorator)

Is there a better way to express this properly ?

# __builtins__.pyi

from typing import Tuple, TypeVar, Final
Const_T = TypeVar("Const_T", int, float, str, bytes, Tuple)  # constant

def const(expr: Const_T) -> Final[Const_T]:
    """ Used to declare that the expression is a constant so that the compiler can optimise it."""
    ...

Code sample in pyright playground

[JelleZijlstra]

It sounds like what you want is that for any assignment a = const(b), the type checker treats it like a: Final = b. Unfortunately, the type system doesn't provide a way to do it. It's not meaningful to say that the return value of a function is Final, since Final is a type qualifier, not a type itself; being Final is a property of individual symbols in a program, not of the type.

I see a few possible ways forward:

• We extend the type system to support micropython.const, either by special-casing just that function or adding some general mechanism. This is possible, but I'll mention that I haven't seen any use cases for this outside of micropython.
• MicroPython is changed so that it recognizes a: Final = b as a constant assignment, consistent with the type system. I don't know how difficult this would be.
• MicroPython accepts that in this case the type system isn't exactly aligned with MicroPython's semantics (i.e., we don't change anything on either side).

[erictraut]

I don't think it makes sense to special-case this in the type system.

@Josveri, if you want to use a static type checker with micropython code, my recommendation is to use an explicit Final with the variable declaration.

a: Final = const(b)

This informs a static type checker that the symbol cannot be reassigned, and the const function tells the runtime to enforce this. If you don't want to use a static type checker with your code, you can omit the Final qualifier.

[Josverl]

Thanks for the sanity check, and I agree that that there are better things to do that special casing this.

For custom python code the a: Final = const(b) notation is acceptable, even though there is a bit of duplication in the syntax, it does clearly convey the developers intent.

Furthermore as a lot of these constants are defined in firmware, for which I'm currently automatically stubs for, it should be possible to generate stubs that include Final in the majority of such declaration as well.