Interop between discriminated unions and the 'is' operator would be great

[AlexGalays]

Code

type A = { type: 'a', a: number }
type B = { type: 'b', b: string }
type Union = A | B

const arr: Union[] = [
  { type: 'a', a: 10 },
  { type: 'a', a: 20 },
  { type: 'b', b: '30' }
]

// It should now have been refined as an A[], but is not
const filtered: A[] = arr.filter(x => x.type === 'a')

Expected behavior:

Just like the compiler can infer that the code under a branch following an if (x.type === 'a') can safely use x as an A, it could be able to do it when using an anonymous function in Array.prototype.filter

Actual behavior:

Instead, one must first define a function :

const isA = (u: Union): u is A => u.type === 'a'

and use it to filter the Array. Note that the body of the function is exactly the same as the anonymous function's above, all it does is giving an extra hint to the compiler by way of the return type. Thus, the anonymous function could be automatically picked up to use the proper Array.prototype.filter definition.

Creating lots of isX boilerplate functions is known to be a tedious task for lots of big unions, it would be nice if it wasn't mandatory.

[aluanhaddad]

Seems like a duplicate of #5101

[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.

[AlexGalays]

oops, thank you bot.