Array<T>.filter should be able to refine T|undefined to T

[Firehed]

TypeScript Version: 2.6.1

Code

interface EntityType {
  id: number,
  name: string,
}
const ids = [1, 2, 3]
const entities = new Map<number, EntityType>()
let relevantEntities: EntityType[] = []
if (ids) {
  relevantEntities = ids.map(id => entities.get(id)).filter(Boolean)
}

Note that I have tried many variants of the argument to filter (x => !!x, x => x !== undefined, etc). I'm only using Boolean here since it works in Flow

Further note that making the following change allows the error checker to proceed, but only through basically lying about the data:

if (ids) {
  // get(id) becomes get(id)!
  relevantEntities = ids.map(id => entities.get(id)!).filter(Boolean)
}

Expected behavior:
Assignment proceeds without error, since any undefined values produced in the map operation are filtered out.

Actual behavior:

error TS2322: Type '(EntityType | undefined)[]' is not assignable to type 'EntityType[]'.
  Type 'EntityType | undefined' is not assignable to type 'EntityType'.
    Type 'undefined' is not assignable to type 'EntityType'.

[RyanCavanaugh]

This is already possible, you just need to define an explicit user-defined type guard:

function notUndefined<T>(x: T | undefined): x is T {
    return x !== undefined;
}
if (ids) {
    relevantEntities = ids.map(id => entities.get(id)).filter(notUndefined);
}

[Astrophizz]

That only works if you pass the type guard as a function reference and don't, for example, call it with an arrow function. This does not work:

function notUndefined<T>(x: T | undefined): x is T {
    return x !== undefined;
}
if (ids) {
    relevantEntities = ids.map(id => entities.get(id)).filter(entity => notUndefined(entity));
}

As far as I know, if you need or want to use an arrow function you need to tell the compiler that you know better than it with an assertion:

function notUndefined<T>(x: T | undefined): x is T {
    return x !== undefined;
}
if (ids) {
    relevantEntities = ids.map(id => entities.get(id)).filter(entity => notUndefined(entity)) as EntityType[];
}

[Firehed]

Thanks @RyanCavanaugh - that solution does appear to work as-is.

It is, however, fairly unintuitive (hence my being here in the first place!) and I think it would be immensely helpful if this "just worked" out of the box. I think it's a fairly common pattern, particularly when working with a normalized store of entities (e.g. Redux).

At the very least, having this documented on the Typescript website (rather than digging around in github issues and stackoverflow) would go a long way for the language's usability, even if it's not (currently?) practical to add first-class support into the language.

[mhegazy]

Duplicate of #20812

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.