Re: Performance

Je suis allé voir ta présentation et j'ai remis un œil dans la doc de mypy que je n'avais pas lue depuis très longtemps. Cela à vraiment progressé, c'est vraiment pas mal.

L'approche des Union est intéressante car elle permet de facilement ajouter / enlever des constructeurs. En contrepartie cela fait des union ouvertes ce qui force à mettre plus de signatures. C'est le sentiment que j'ai avec mypy, il faut mettre des informations de type partout si tu veux que cela fonctionne.

La documentation me dit que "User-defined generics are a moderatly advanced feature" et cela m'attriste car c'est juste la base du typage (et des trucs amusants). Note: mypy utilise le terme Generic là ou une énorme partie de la littérature utilise le mot polymorphisme.

Je trouve que beaucoup de choses sont verbeuses, mais c'est principalement une limitation de python qui n'a pas de syntaxe pour faire du pattern matching.

@dataclass
class Left(Generic[T]):
 left: T
@dataclass
class Right(Generic[T]):
 right: T
either = Union[Left[V], Right[T]]
def tortue(d: T, v : either[T, V]) -> T:
 if isinstance(v, Left):
 return v.left
 else:
 return d

Donnerais, en Haskell:

data Either v t = Left v | Right t
tortue d e = case e of
 Left v -> v
 Right _ -> d

Dans le précèdent exemple, je n'ai pas encore réussi à comprendre comment il s'en sort pour affecter V et T à str et int respectivement. L'inférence est assez bonne, je n'arrive à la mettre en défaut que dans quelques rares cas.

Je n'arrive pas à faire de types calculés ? Par exemple, une fonction type:

def bar(t1, t2):
 return ...
def foo(a: T1, b: T2) -> bar(T1, T2)

J'ai essayé rapidement sans succès. Avec bar(T1, T2) il refuse et me demande d'utiliser bar[..] et avec cette approche (et bar une instance de class avec __getitem__), il refuse.

Merci de m'avoir donné envie de donner une nouvelle chance à mypy, cela à fait du progrès. Je le sortirais la prochaine fois que je ferais une intervention chez un client qui refuse de faire du Haskell ;)