Re: What's wrong with C++?

["Peter C. Chapin" <PChapin@vtc.vsc.edu>]

On Fri, 18 Feb 2011, Chuck wrote:

>> You can still define the types you need. Inference just means that you 
>> typically don't have to bother with explicit declarations: create the 
>> objects you need (of the types you need) and let the compiler work out 
>> the details.
>
> And the the MAINTAINER try to figure out WTF is going on with the
> UNREADABLE code! Uncomprehensible code is useless code.

I agree that rampant type inference isn't good for readibility. But as has 
been mentioned here elsewhere, even languages that support aggressive type 
inference typically require type annotations in interfaces (aka 
specifications). Anyway, I like the way Scala does type inference. You do 
have to annotate parameter types of methods but the compiler can infer the 
types on locals and also on function literals that are embedded inside other 
expressions. For instance:

def simpleMethod(counters: List[Int]) =
   counters filter { _ > 1 }

In this trivial example the compiler infers the type of the function literal 
as Int => Boolean based on its use as a argument to the filter method as 
applied to a list of integers. The return type of simpleMethod is also 
inferred as a list of integers as well (the result of filter).

The fact that you have to annotate the parameter types and yet don't have to 
bother annotating all the local types seems like a good compromise between 
documentation and conciseness.

In any case, functional languages are becoming industrially significant. 
Microsoft is fully supporting F# (an OCaml dialect) and Scala is doing well 
in the Java ecosystem. I think we will see more of this sort of thing in the 
future rather than less.

Peter