typescript generic type and undefined

Question

I'm looking at facebook's immutable library and their typescript bindings.

If I have this code:

const list: User[] = ...;
list.map(user => ...)

The type of the lambda parameter user is correctly User.

However, if I import immutable's List and wrap my array:

import {Map, List} from "immutable";
List(list).map(user => ...)

Now, and it's baffling to me, the lambda parameter user is inferred to be User | undefined. Even changing the call to List<User>(list) does not help.

Looking at the .d.ts for the library, the definition is:

export function List<T>(array: Array<T>): List<T>;

So I don't understand what is going on here?

Answer 1

The reason for this is written in the What's new in TypeScript 2.0 in the Optional parameters and properties part:

Optional parameters and properties automatically have undefined added to their types, even when their type annotations don't specifically include undefined. For example, the following two types are identical:

// Compiled with --strictNullChecks
type T1 = (x?: number) => string;              // x has type number | undefined
type T2 = (x?: number | undefined) => string;  // x has type number | undefined

---

Edit

The definition file for immutable.js changed, now if you look at the signature of the map method it looks like this:

map<M>(
    mapper: (value: V, key: K, iter: /*this*/Iterable<K, V>) => M,
    context?: any
): /*this*/Iterable<K, M>;

But if you go a commit before that it looks like this:

map<M>(
    mapper: (value?: V, key?: K, iter?: /*this*/Iterable<K, V>) => M,
    context?: any
): /*this*/Iterable<K, M>;

And here the value is optional.

If you update the definition file it will be fixed.