The way sum is defined, the return value is open-ended; more than one type can implement the trait Sum<i32>. Here’s an example where different types for a are used, both of which compile: #[derive(Clone, Copy)] struct Summer { s: isize, } impl Summer { fn pow(&self, p: isize) { println!(“pow({})”, p); } } impl std::iter::Sum<i32> … Read more
The problem is that the type inference has been improved. You have a method like public <T extends Base> T get() { return (T) new Derived(); } which basically says, “the caller can decide what subclass of Base I return”, which is obvious nonsense. Every compiler should give you an unchecked warning about your type … Read more
EDIT Better/recent info is here: Keeping partially applied function generic (original below) I think a pragmatic thing here is not to try to understand this too deeply, but rather to know a couple general strategies to get past the VR and move on with your work. It’s a bit of a ‘cop out’ answer, but … Read more
The general principle here is that type information flows only “one way”, from the inside to the outside of an expression. The example you give is extremely simple. Suppose we wanted to have type information flow “both ways” when doing type inference on a method R G<A, R>(A a), and consider some of the crazy … Read more
Why ? Because the type inference of generics types has not been expanded to chained invocation. From the java tutorial on generics type inference: The notion of what is a target type has been expanded to include method arguments. That is why this code: f(Map.empty()); compiles. But this code doesn’t because this is a chained … Read more
It is hard to give a static type to the apply function, since its type depends on the type of the (possibly heterogeneous) list argument. There are at least two ways one way to write this function in Haskell that I can think of: Using reflection We can defer type checking of the application until … Read more
You want something like partial type parameter inference, which is not currently a feature of TypeScript (see microsoft/TypeScript#26242). Right now you either have to specify all type parameters manually or let the compiler infer all type parameters; there’s no partial inference. As you’ve noticed, generic type parameter defaults do not scratch this itch; a default … Read more
I think that one should use the auto keyword whenever it’s hard to say how to write the type at first sight, but the type of the right hand side of an expression is obvious. For example, using: my_multi_type::nth_index<2>::type::key_type::composite_key_type:: key_extractor_tuple::tail_type::head_type::result_type to get the composite key type in boost::multi_index, even though you know that it is … Read more
Is there a philosophical reason why the constructor can’t support type inference? No. When you have new Foo(bar) then we could identify all types called Foo in scope regardless of generic arity, and then do overload resolution on each using a modified method type inference algorithm. We’d then have to create a ‘betterness’ algorithm that … Read more
A bunch of people have pointed out that C# does not make inferences based on constraints. That is correct, and relevant to the question. Inferences are made by examining arguments and their corresponding formal parameter types and that is the only source of inference information. A bunch of people have then linked to this article: … Read more