👍

@ahejlsberg You've got a little typo in your code example: isUndefined<T> should use or rather than and, shouldn't it? Just trying to avoid confusion here.

function isUndefined<T>(x: Maybe<T>): x is void {
    return x === undefined || x === null;
}

@mariusschulz Yes indeed, thanks for catching that.

Will this address issue mentioned in #3215 ?

@ENikS No, the two are unrelated.

@ahejlsberg Would inferring T more accurately in the following scenario be worthwhile:

interface A { a: any; }
function test<T>(arg: A & T): T { ... }
let result = test({a: "", b: 10});

The type of result is inferred as {}, although I would expect it to be inferred as {b: number}. Admittedly I don't have a very clear use case for this at the moment.

@masaeedu We could potentially explore that, but it could get complex and would require type inference to manufacture new types, neither of which I'm crazy about. Specifically, in your example, we'd have to manufacture a new type { b: number } and infer that for T. I think it is desirable to have the property that type inference never infers types that don't already occur in your code.