Typescript 在参数中强制使用别名类型

Question

I am currently having an issue with type unions/aliases. I have an alias for values which might be null or undefined and a function that handles these values.

This works fine and everything is safe. No there are situation where through oversights or whatever, a safe value, which can't be null or undefined is passed to the function. This does not break anything, because the function expects safe values aswell, but Typescript does not complain.

The code looks something like this:

type Maybe<T> = T | null | undefined;

function handleDangerousValue<T>(val: Maybe<T>): T {
    // Check stuff
    return val as unknown as T;
}

const safeValue: number = 1;
const unsafeValue: Maybe<number> = null;

// Would like a type error here
handleDangerousValue(safeValue);

// This is fine
handleDangerousValue(unsafeValue);

I would like to somehow have Typescript tell me that safeValue does not have the correct type.

I know that this does not work because of how the union type is defined, but I do not know any solution on how to enforce this. This would probably be solvable by having DangerousValue<T> become a class, but I would prefer it as a type, as I do not want extra boilerplate to solve a typing problem.

edit:

I tinkered a bit more and got some progress:

type Maybe<T> = T | null | undefined;
type EnforceMaybe<T> = Maybe<T> extends T ? Maybe<T> : never;

function handleDangerousValue<T>(val: EnforceMaybe<T>): T {
    // Check stuff
    return val as unknown as T;
}

const safeValue: number = 1;
const unsafeValue: Maybe<number> = null as Maybe<number>;

// Correctly finds issue
const n1: number = handleDangerousValue(safeValue);

// Now thinks that the return type should be a Maybe
const n2: number = handleDangerousValue(unsafeValue);

Now the values that can't be null are not allowed, but typescript is not able to infer the inner type of the Maybe anymore.

Can I somehow infer that for the return type?

Answer 1

Solved it by casting the return type:

type Maybe<T> = T | null | undefined;
type EnforceMaybe<T> = Maybe<T> extends T ? Maybe<T> : never;

function handleDangerousValue<R extends NonNullable<T>, T>(val: EnforceMaybe<T>): R {
    // Check stuff
    return val as unknown as R;
}

const safeValue: number = 1;
const unsafeValue: Maybe<number> = null as Maybe<number>;

// Correctly finds issue
const n1: number = handleDangerousValue(safeValue);

// Now thinks that the return type should be a Maybe
const n2: number = handleDangerousValue(unsafeValue);

I know that the value will not be null when returning, therefore it should be fine to cast it. For casting I created a second generice which gets the original type out of the Maybe type.

Now I can't pass non-nullable values to the function but will get the correct return type if one is passed.

Playground Link