通用函数中的联合类型

Question

I have code that looks like this:

/** explains the absence of a value */
export interface None {
    'is none because': string;
    // has spaces to reduce likelihood of a non-None having this member
}

/** Either a value or a reason why that value is missing. */
export type Optional<a> = a | None;

/** Possible value actually is a value */
export function isSome<a>(optValue: Optional<a>): optValue is a {
    return !('is none because' in optValue);
}

/** Possible value actually is absent */
export function isNone<a>(optValue: Optional<a>): optValue is None {
    return 'is none because' in optValue;
}

/** Consider optional value, require users to consider both possibilities */
export function outOfOptional<a, r>(value: Optional<a>, haveSome: (some: a) => r, haveNone: (reason: string) => r): r {
    if (isNone(value)) {
        return haveNone(value['is none because']);
    }
    else {
        return haveSome(value);
    }
}

I'm finding two problems with this set-up, however. Both are related to the automatic deduction of the generic types in these utility functions.

First, isSome does not seem to work as a typeguard:

if (isSome(value)) {
    // value here is still treated as a | None
}

It seems that the default deduction here is isSome<Optional<a>> , which quite frankly is wrong ( isSome<Optional<a>> should expect an argument of Optional<Optional<a>> , which is not what it's getting here). If I'm explicit and use isSome<a> , then it works, but I decidedly do not want to do that.

Alternatively, isNone does work, which is why you see it used in outOfOptional : value has type a in the else block.

In addition, consider this usage of outOfOptional :

export function outOfBothOptional<a, b, r>(
    one: Optional<a>, another: Optional<b>,
    haveBoth: (one: a, another: b) => r,
    haveFirst: (one: a) => r,
    haveSecond: (another: b) => r,
    haveNone: (none: string) => r
): r {
    return outOfOptional(
        one,
        haveOne => outOfOptional(
            another,
            haveAnother => haveBoth(haveOne, haveAnother),
            () => haveFirst(haveOne)
        ),
        () => outOfOptional(
            another,
            haveSecond,
            haveNone
        )
    );
}

Both haveOne and haveAnother are deduced to be a | None a | None rather than a , even though this leads to an error, and even though they could not be . In effect, outOfOptional here seems to be treated as outOfOptional<Optional<a>> , except that's wrong, for the same reason isSome<Optional<a>> was wrong. The first argument is Optional<a> , not Optional<a> | None Optional<a> | None or Optional<Optional<a>> as that deduction would imply. Given a first argument of Optional<a> , the generic type of outOfOptional must be a and definitely not Optional<a> .

Why does TypeScript consider this a valid, and in fact more valid , deduction? Is there anyway I can use a | None a | None as an optional type, without having to explicitly indicate generic types in the related functions?

Answer 1

Your intuition that this should be inferrable is correct, and in fact the current nightly build of TypeScript ( npm install typescript@next ) does infer the correct type now.

See the PR that fixed this https://github.com/Microsoft/TypeScript/pull/5895 and the originating bug https://github.com/Microsoft/TypeScript/issues/5861