4 ms·

Well, the parsing issues go away mostly because the actual pattern is "keyword on the left, type on the right". `let a: My_Type` is a whole lot easier to parse

• int_19h 8y ago
  `a: My_Type` or even `a My_Type` (assuming that juxtaposition is not used for something else) is easier to parse, since you only need one token of lookahead here to know that it's a declaration, and that the rest is a type constructor - and this is true regardless of how complicated that type constructor is. For an extreme example on the other end of the spectrum, in C++, for something like this: a<>::b<c>d; It's impossible to even say whether it's an expression statement or a variable declaration, because it depends on what exactly b is. In fact, it might be impossible to determine even if you have the definition of b in pure C++. Consider: template<size_t N = sizeof(void*)> struct a; template<> struct a<4> { enum { b }; }; template<> struct a<8> { template<int> struct b {}; }; enum { c, d }; int main() { a<>::b<c>d; } Now whether it's a declaration or an expression depends on pointer size used by your compiler. Needless to say, this is all very fun for tools that have to make sense of code, like IDEs. And I think that's another vector for a different syntax - as "smart" tooling (code completion etc) became more common, PL designers have to accommodate that, as well. C++ helped by first becoming popular, and then teaching several painful lessons in that department.