A few things are going on here. The first (minor) issue is that, with your Student interface, the compiler will not treat checking the isValid property as a type guard: const s = students[Math.random() < 0.5 ? 0 : 1]; if (s.isValid) { foo([s]); // error! // ~ // Type ‘Student’ is not assignable to … 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
The new interpolated string syntax is part compiler magic and part runtime classes. Let’s go through all the scenarios and see what is actually happening. var s = $”{DateTime.Now}”; This gets compiled as this: string s = string.Format(“{0}”, DateTime.Now); See Try Roslyn for details. string s = $”{DateTime.Now}”; This gets compiled as this: string s … Read more
Great question. The difference is that f and g are function expressions, where h is a function declaration. When a function is throw-only, it gets the type never if it’s an expression, and void if it’s a declaration. Surely the above paragraph doesn’t actually help. Why is there a difference in behavior between a function … Read more
Just above that example, it says if e is an unparenthesized id-expression or a class member access (5.2.5), decltype(e) is the type of the entity named by e. if e is an lvalue, decltype(e) is T&, where T is the type of e; I think decltype(a->x) is an example of the “class member access” and … Read more
decltype gives the declared type of the expression that is passed to it. auto does the same thing as template type deduction. So, for example, if you have a function that returns a reference, auto will still be a value (you need auto& to get a reference), but decltype will be exactly the type of … Read more
auto was a keyword that C++ “inherited” from C that had been there nearly forever, but virtually never used because there were only two possible conditions: either it wasn’t allowed, or else it was assumed by default. The use of auto to mean a deduced type was new with C++11. At the same time, auto … Read more
This is because a type parameter has a bound: <T extends String> => String <T extends String & AutoCloseable> => String & AutoCloseable And the bytecode after erasure is the same as for the regular main declaration in both cases: public static main([Ljava/lang/String;)V JLS §4.4. Type Variables: The order of types in a bound is … Read more
decltype also considers whether the expression is rvalue or lvalue . Wikipedia says, The type denoted by decltype can be different from the type deduced by auto. #include <vector> int main() { const std::vector<int> v(1); auto a = v[0]; // a has type int decltype(v[0]) b = 1; // b has type const int&, the … Read more
This is actually a legitimate type inference*. We can reduce this to the following example (Ideone): interface Foo { <F extends Foo> F bar(); public static void main(String[] args) { Foo foo = null; String baz = foo.bar(); } } The compiler is allowed to infer a (nonsensical, really) intersection type String & Foo because Foo is … Read more