Similarly, is there any reason the example `add` function in the OP shouldn't be able to add strings, or lists?
I've seen a lot of these quick-runtime-type-checking libraries, but they always have the same problem as manual type-checking: they make the constraints much stricter than they need to be and prevent entire classes of useful behavior.
Python 3 annotations are already not used in any specific predetermined way, so if you create a system to do something with type annotations then you can implement List(str) or whatever it is you want an annotation to work like.
True, list comprehension is often used instead. But a complete typing system should be able to type-check that too. The point is not changed.
Also, I only used map and filter as an example. Python programmers tend to write a lot of generics functions without actually knowing it.
def f(g, *args):
...
r = g(*args)
...
return r
This function is actually quite generic, akin to map.And we are not yet getting into the realm of "trait" or "concept" or "typeclass" or whatever.
def sum(*nums):
s = 0
for n in nums:
s += n
return s
Remember, although s is definitely an int, s + n may yield some completely unrelated type if n implements __radd__. The function here involves potentially infinite number of types, and their __add__ or __radd__ traits (reusing the name of the Python magic method). To fully express its type without unnecessary constraints is an interesting exercise. Since Python allows dynamic parameter list building (like sum(*nums)), dependent typing may be necessary for that purpose.Ocaml/SML are both functional languages similar to haskell, and allow IO pretty much anywhere. They don't have typeclasses, (although ML people would say there's nothing you can't do with the ML module system[0]).
In Haskell map is
map :: (a->b) -> [a] -> [b]
How could we do something like that in a Python type extension? One way would be to just use the Haskell notation in quotes: @type("(a->b) -> [a] -> [b]")
def myMap(fn, as):
#...etc...
An alternative would be to define a function Fun for describing functional types, and gen.{something} for a generic type, e.g.: @type(Fun(gen.a, gen.b), [gen.a], ret=[gen.b])
def myMap ...etc...
But that notation doesn't (at least to me) look as clean as the Haskell. map : ('a... -> 'b) -> ('a list)... -> 'b list
Where <type>... denotes <type1> -> <type2> -> ... -> <typeN> spliced into the type signature, with each type variable 'a in <type> replaced with 'a1, 'a2, ... 'aN. You could cover tuples too: zip : ('a list)... -> 'a,,, list
Bit ugly, and writing a type checker for it could be fun, but it seems workable.Right, looks very similar.
However, behold the byzantine Scheme numerical tower and the effort to type it: http://www.ccs.neu.edu/home/stamourv/papers/numeric-tower.pd...
args = []
while some_condition():
args.append('x')
f(*args)
Typed Racket allows you type some common cases, though. uint8_t foo = (uint8_t)69;
In theory, there should be no need to specify the type twice. The ideal circumstance is something like uint8_t foo = 69; List<String> list = new ArrayList<String>();
It feels silly to have to write the type parameter twice. But now you can say: List<String> list = new ArrayList<>();
It's usually not a huge deal, but occasionally the stutter can be more pronounced: Map<String, List<Map<Integer, Set<Float>>>> map = ...
I believe that dynamic typing results from frustration over generics, rather than over static typing in general. (Type stuttering is another problem, but modern languages solve it with local type inference.) I mean, annotating non-generic functions is always straightforward doesn't introduce much complexity:
However, it's much harder to write a type annotation of generic functions. Worse, remember that Python's map is variadic. Many mature static typing systems would allow you to express such types (usually called parameterized types). But any one of them would require more than those trivial notations in print.That's when the dynamic typing people get annoyed and go "fxxk static typing systems, I can handle this in my mind". Which is about 65% (totally random estimation) the point of dynamic typing in my opinion.
Any type checker for dynamic typed languages that doesn't seriously try to solve the generics problem is not genuinely interesting.