Way to specify that type can't be null

[Pajn]

TypeScript Version: 2.2.1

Code

With the code

function filterMap<T, U>(data: Array<T>, fn: (element: T) => U): Array<U> {
 let newArray: Array<U> = []
 data.forEach(element => {
 let newElement = fn(element)
 if (newElement != null) {
 newArray.push(newElement)
 }
 })
 return newArray
}

let fruits = ['apple', 'banana', 'pear']
let filteredAndMapped = filterMap(fruits, e => e.startsWith('a') ? null : e.toUpperCase())

filteredAndMapped now have the type Array<string | null> but in reality only contain elements of type string.

It would be nice if it was possible to do a non-null assertion or similar for types, allowing me to write something similar to

function filterMap<T, U>(data: Array<T>, fn: (element: T) => U): Array<U!> {
 let newArray: Array<U!> = []
 // ...

so that filteredAndMapped and newArray have the type Array<string>.

[NN---]

You can try f<T extends {}>(x: Array)

[aluanhaddad]

Emma (@Pajn) that is already supported

declare function filterMap<T, U>(data: Array<T>, fn: (element: T) => U | null): Array<U>;

[Pajn]

Aluan Haddad (@aluanhaddad)
That works if the types are inferred (which is great!) but if you explicitly pass a nullable type into U it doesn't. It would be nice to be able to do that to. Especially as you must specify the type parameters when using a type in a type bound and thus can not rely on that trick inside a type.

[aluanhaddad]

I'm not sure I follow you. When you say explicitley pass a nullable type for U do you mean

filterMap(fruits, e => null))

or

filterMap<string, string | null>(fruits, e => null))

If so, you can write overload such as

declare function filterMap<T, U extends null>(data: T[], fn: (element: T) => U): [never];
declare function filterMap<T, U>(data: T[], fn: (element: T) => U | null): U[];

[Pajn]

I have wanted this a couple of times the last days with the use case of taking property from another type but requiring it.

Example

type A = {prop?: string}
type B = {prop: A['prop']} // type of B is {prop: string|undefined}
// I would like
type B = {prop: A['prop']!} // type of B is {prop: string}

[mhegazy]

Duplicate of #14366

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

[mhegazy]

This should be possible now with NonNullable<A["prop"]>. see #21847