I just don't understand why there has to be a tradeoff. I just don't get why the compiler should decide on such a large thing, instead of letting the programmer do it. One can always be more explicit if one feels they're getting value from it. If someone wants to write a bunch of terse code, why stop them? Does the compiler gain a large benefit from not having to include this feature? Who loses by allowing users to do what they want?
Comparing C# and F#, the extra annotations change the frequency in which I'll introduce an inner (local) function. For instance, here's a little helper in a piece of code I'm writing at the moment. It's part of a larger function and isn't exposed beyond 5 lines of code.
let runWithLog f name =
try run f name with ex -> logExn ex
Used in:
runWithLog "sessions" collectSessionStats
runWithLog "visitors" collectVisitorStats
Having to add "(f: string -> RunParams -> Whatever -> unit) (name: string)" almost doubles runWithLog helper yet provides no benefit. And this an extremely simple case! Once the arguments are generic, higher-order functions themselves, it gets quite noisy.
Sure, if it's a top-level export, then maybe annotating is a good idea. But if it's limited in scope then what's the harm?
Not that it'll change when I use Rust - there's nothing competing in this category. It'd just be nice if the language let the user decide on the style.
Rust will do type inference on lambdas for you. :-)
fn fubar(x: uint) {
let times = |n| x * n;
println!("{} * 5 = {}", x, times(5));
}
Rust only enforces type annotations on top-level functions.
> Does the compiler gain a large benefit from not having to include this feature? Who loses by allowing users to do what they want?
FWIW, I feel precisely the opposite as you. I'd rather have an ecosystem of code where top level functions must be annotated by types than an ecosystem where types are there only if the author feels like adding them. There is a small cost but a large gain, IMO.
There are `fn` types---which are just function pointers---and there are `||` types, which are closures that correspond to a pointer to a function and an environment.
You can actually define `fn`'s within other `fn`'s, but their types are not inferred. Closures cannot be defined at the top level, presumably because there is no global environment to capture. (Rust does have global "static" constants, though, which are available everywhere in the enclosing module I think.)
I can probably hazard a few guesses at why there is a split here (probably relating to lifetimes), but I don't know for sure. Perhaps someone else will chime in.
The immediate difference is the body of what you need to infer against. In the local case it's quite small, and the compiler doesn't have to worry about a lot of what-ifs.
Personally I like seeing types and I'm glad people are forced to write them. (This is an opinion I've had long before Rust existed, so I'm not rationalizing excuses.)
> Who loses by allowing users to do what they want?
Everyone else who looks at your code who would have preferred them.
I dabble with both Go and Haskell, and this seems like the best of both worlds: from Go they enforce a uniform standard across libraries, coworkers' code, etc, and from Haskell, they're adopting the philosophy that "types are documentation".
I, too, would be a little annoyed at documenting lambdas, like this, but I think it's eminently reasonable to require it for all top-level function definitions. And it sounds like from another comment here, that that's the case. :)
Comparing C# and F#, the extra annotations change the frequency in which I'll introduce an inner (local) function. For instance, here's a little helper in a piece of code I'm writing at the moment. It's part of a larger function and isn't exposed beyond 5 lines of code.
Used in: runWithLog "sessions" collectSessionStats runWithLog "visitors" collectVisitorStatsHaving to add "(f: string -> RunParams -> Whatever -> unit) (name: string)" almost doubles runWithLog helper yet provides no benefit. And this an extremely simple case! Once the arguments are generic, higher-order functions themselves, it gets quite noisy.
Sure, if it's a top-level export, then maybe annotating is a good idea. But if it's limited in scope then what's the harm?
Not that it'll change when I use Rust - there's nothing competing in this category. It'd just be nice if the language let the user decide on the style.