5 ms·
That's the main issue with advanced type systems that feature things like union types, generics/polymorphism, subtyping... It's hard to specify the line between
by tomp 12y ago
That's the main issue with advanced type systems that feature things like union types, generics/polymorphism, subtyping... It's hard to specify the line between type inference guessing correctly what the programmer wants, and type inference now catching a programmer's bug. This is the reason that most Hindley-Milner type systems (e.g. OCaml's) don't allow recursive types (which come up e.g. for typing the Y combinator).
Another example is:
function equal<T>(lhs: T, rhs: T): boolean {
return lhs === rhs;
}
var e = equal(42, 'hello');
Here, there obviously is a type for `T`: `any` (the toplevel dynamic type) or `number|string`.
This problem is caused by the requirement that type inference is "complete", i.e. that it correctly infers types for all programs that have a valid typing (i.e. that would work if the programmer specified all types).
- Retra 12y agoThis makes me wonder what the point of writing 'var' is if it doesn't tell you the type of the variable.
- UberMouse 12y agoSo variables are explicitly declared, don't have issues of mis typing a variable name and accidentally declaring a new one. Note: This is just my thinking, I don't know if it's the actual reason
- Retra 12y agoThat's a sensible reason, sure, but I'd rather declare it with an actual type instead.
- tomp 12y agoAs opposed to doing what?
- thomasahle 12y agoLike python, just `e = equal(...`
- tomp 12y agoPython had to go through a lot of pain for that, the "nonlocal" keyword was only added in Python 3.0, and the local/global distinction is very fragile. Javascript and Coffeescript try to solve this in different ways, most people think that JavaScript's method sucks, and many are not fond of CoffeeScript's non-locality. Personally, I think that demanding variable declaration is still the best option (possibly except for interactive sessions).
- thomasahle 12y agoYes, for complicated things like this, explicitly declaring the type is probably preferable.
- lpw25 12y agoActually OCaml does support recursive types. Recursion through objects and polymorphic variants is always supported, and full recursive types can be turned on with the `rectypes` command-line option.