Why can’t Ambroses support type notes?

Question

We know that Python, as of version 3.6, supports annotating types in functions and variables, according to the PEP 526 -- Syntax for Variable Annotations and PEP 3107 -- Function Annotations.

def int2float(x: int) -> float:
    return float(x)

a: int = 2
b: float = int2float(a)

However, even after the implementation of these Peps Amblas do not have type annotation support.

int2float = lambda x: int: float(x)

I believe that in this case would break the syntax and generate redundancy because it would not be possible to define whether the lambda is just lambda x: int, returning to class int, or if this is the type annotation. However, I believe that adding parentheses, which are currently not supported, would solve the problem:

int2float = lambda (x: int) -> float: float(x)

Apparently they decided that this would be unfeasible or that it would not make sense (except for the fact that the language is dynamic typing).

Why did you choose not to add type annotations in lambda? They didn’t see the need or it doesn’t make sense for a lambda to have type annotations?

Answer 1

Well, according to PEP 3107 there really is no type annotations support for lambda functions and the reason for this is described in PEP itself (my free translation):

The syntax of a lambda function could have been changed to support annotations, being needed to add parentheses around the parameter. However decided do not make such changes because:

• It would be an incompatible change
• Lambdas are "castrated" anyway.
• A lambda can always be ported to a function itself.

By "castrated," I imagine they said they were less complex functions than a normal function.

The justification Guido gave by email was that in order for the lambda to accept the type annotations it would take extra parentheses around the annotations so that the interpreter would not be confused with the : of the annotations and the : that comes before the function itself.

However, it ends the email with

Fortunately this is at least one of those Things that we can fix with a Purely syntactical source code Transformation...

which may mean that at some future time these functions may also gain note. (:

Currently, if you want to make the type annotations, either you turn your lambda function into a common function or you can use the module Callable to make the note, as described in that matter