The return type of a method is either the type of the last statement in the block that defines it, or the type of the expression that defines it, in the absence of a block. When you use return inside a method, you introduce another statement from which the method may return. That means Scala … Read more
Below are alternative explanations with a varying amount of detail, depending on how much of a hurry you’re in. 😉 I will use the following code (drawn from that other question) as a running example. Here, the type annotation on the definition of reduce is actually required to make it typecheck. (* The type [(‘a, … Read more
Get<S, T> takes two type arguments. When you call service.Get(new Signatur()); how does the compiler know what T is? You’ll have to pass it explicitly or change something else about your type hierarchies. Passing it explicitly would look like: service.Get<Signatur, bool>(new Signatur());
See this scala-debate thread for a discussion of what’s going on here. The problem is that Scala’s type inference happens per parameter list, not per parameter. As Josh Suereth notes in that thread, there’s a good reason for the current approach. If Scala had per-parameter type inference, the compiler couldn’t infer an upper bound across … Read more
When you say val s = l.toSet the compiler figures that the only sensible type for toSet is Char–that’s the most specific choice. Then, given that s is a set of Char, the compiler realizes that the map must be from a Char. But in the second case, it withholds judgment on what the type … Read more
Holger had the best answer in the comment section in my opinion: This is a known limitation of Java 8’s type inference: it doesn’t work with chained method invocations like genericFactoryMethod().build(). Thanks! About my API, I will specify the functions before using them as arguments, like this: Function<Entry<String, Set<String>>, String> keyMapper = Entry::getKey; Function<Entry<String, Set<String>>, … Read more
Rust uses Hindley-Milner type system. It is a set of rules about establishing types of expressions based on their usage. Formal description and explanation for it can be found there: “What part of Hindley-Milner do you not understand?”
Regarding “Haskell’s equally powerful inference”, I don’t think Haskell has to deal with OO-style dynamic subtyping (type classes can do some similar stuff, but type classes are easier to type/infer) method overloading (type classes can do some similar stuff, but type classes are easier to type/infer) That is, I think F# has to deal with … Read more
The issue you’re encountering is that even though the method emptyList() returns List<T>, you haven’t provided it with the type, so it defaults to returning List<Object>. You can supply the type parameter, and have your code behave as expected, like this: public Person(String name) { this(name,Collections.<String>emptyList()); } Now when you’re doing straight assignment, the compiler … Read more
Yuck, yeah, I see that the default inference doesn’t work deeply enough to unroll Iterable<Iterable<T>> into T. It’s not that surprising if you look at how the typings for Iterable are defined in the relevant library: interface Iterable<T> { [Symbol.iterator](): Iterator<T>; } An Iterable<T> has a symbol-keyed method whose return type is Iterator<T>, which itself … Read more