Nested conditional generic types yields boolean not assignable to true | false | undefined.

[Griffork]

TypeScript Version: 2.8RC

Search Terms:

Code

End of friday, so I don't have enough time to make a proper repro, hopefully this will be enough to go by:

    type RecursivePartial<T> = { [param in keyof T]?: T[param] extends object ? RecursivePartial<T[param]> : T[param] };

    interface UpdateValue<T> {
        $set: T extends object? RecursivePartial<T>: T;
    }

    interface ArrayUpdate<T> {
        $wildcard: WriteQuery<T>;
    }
    export type TypeWriteQuery<T> =
        T extends Array<infer U>
        ?
            Partial<ArrayUpdate<U>>
        :
            T extends object
            ?
                WriteQuery<T>
            :
                Partial<UpdateValue<T>>
        ;

    export type WriteQuery<T> = { [param in keyof T]?: TypeWriteQuery<T[param]> };
///----- Erroring code:
interface Approved {
    approved: boolean;
}
var check = <WriteQuery<Approved>>{ approved: { $set: true } };

Expected behavior:
Works fine (unless I've made another mistake).

Actual behavior:
Errors that boolean isn't assignable to true | false | undefined because boolean isn't assignable to false.

[Jessidhia]

I've gotten a similar error but with an object instead.

interface Stamp {
  id: number
  imageUrl: string
  /** Hide from the list of new stamps. */
  hidden: boolean
}
type StampOptions = Pick<Stamp, 'hidden'>

const defaultOptions: StampOptions = {
  hidden: false
}

// The | StampOptions is something similar to React.Component#setState from @types/react
declare function makeStamp<Keys extends keyof StampOptions> (id: number, options?: Pick<StampOptions, Keys>|StampOptions): Stamp

function makeStampSeries<Keys extends keyof StampOptions> (seriesId: number, options?: Pick<StampOptions, Keys>|StampOptions, count = 10): ReadonlyArray<Stamp> {
  return Array.from({ length: count }, (_, i) => makeStamp(seriesId * 100 + i + 1, options))
}

Argument of type 'Pick<Stamp, "hidden"> | Pick<Pick<Stamp, "hidden">, Keys> | undefined' is not assignable to parameter of type 'Pick<Stamp, "hidden"> | Pick<Pick<Stamp, "hidden">, "hidden"> | undefined'.
  Type 'Pick<Pick<Stamp, "hidden">, Keys>' is not assignable to type 'Pick<Stamp, "hidden"> | Pick<Pick<Stamp, "hidden">, "hidden"> | undefined'.
    Type 'Pick<Pick<Stamp, "hidden">, Keys>' is not assignable to type 'Pick<Pick<Stamp, "hidden">, "hidden">'.
      Property 'hidden' is missing in type 'Pick<Pick<Stamp, "hidden">, Keys>'.

This Pick trickery is used to get, effectively, the same effect as Partial, but without allowing random undefined values.

[ahejlsberg]

@Griffork I'm not seeing any errors with your example.

[Griffork]

@ahejlsberg My apologies, in my rush I missed one important part of the code, here's the updated sample:

type RecursivePartial<T> = { [param in keyof T]?: T[param] extends object ? RecursivePartial<T[param]> : T[param] };

interface UpdateValue<T> {
    $set: T extends object? RecursivePartial<T>: T;
}
interface ArrayUpdate<T> {
    $wildcard: WriteQuery<T>;
}
export type TypeWriteQuery<T> =
    T extends Array<infer U>
    ?
        Partial<ArrayUpdate<U>>
    :
        T extends object
        ?
            WriteQuery<T>
        :
            Partial<UpdateValue<T>>
    ;

export type WriteQuery<T> = { [param in keyof T]?: TypeWriteQuery<T[param]> };


export async function Send<T>(Url: string, write?: WriteQuery<T>, options?: any): Promise<T[]> {
    return [];
}

///----- Erroring code:
interface Approved {
    approved: boolean;
}

Send<Approved>("doot",
{ approved: { $set: <boolean>true } });

It needed the object literal to be passed into the function call for it to work.

Edit: Casting the object literal directly to the type expected by the function <WriteQuery<Approved>> works, so I'll use that for now.

[ahejlsberg]

Best I can tell this is working as intended. The issue here is that the conditional type in TypeWriteQuery<T> is distributive (see definition in #21316). Thus, when T is a union type (such as boolean), the conditional type is applied to each of the constituents of the union type (i.e. true and false). There is more discussion on this topic in #22596.

[Griffork]

It's intended that it errors when the type is enforced by a function but not when its cast to or assigned to that type?

[Griffork]

Argh, can't edit post on mobile.
It only worked above because of the cast.

And it's working as intended that any other type works fine, but booleans can't be passed to functions without a cast?

[RyanCavanaugh]

@Griffork the linked issue demonstrates how to cause a conditional type to not distribute over unions

[Griffork]

@RyanCavanaugh I've read through the issue twice now and don't understand how anything in there solves my problem.

What I have read is this:

The fact that the unit type boolean has a finite number of values shouldn't lead to magically different behavior compared to its infinitely-domained counterparts. This is especially confusing because the user never wrote a union type in the above example.

Which seems to imply my above example is a bug, since every atomic type but boolean works this way.

Also I don't understand why boolean has to expand to true|false. If I wanted true|false then I'd write true|false.

[ahejlsberg]

@Griffork The boolean type is exactly equal to true | false. There is zero difference between the two.

The issue you're seeing isn't specific to boolean. Any union of literal types will have the same issues. For example, using a type ApprovalStatus = "yes" | "no" instead of boolean also wouldn't work in your example. In fact, your code only works with string and number because they happen to be infinite types that (by necessity) are treated differently than union types.

As I mentioned above, you can use the techniques in #22596 to control whether and how the TypeWriteQuery<T> distributes over union types.

[Griffork]

@ahejlsberg apparently I'm missing something obvious, but when reading through #22596 I didn't see any "techniques" that solve my problem. Is it too much for me to ask for you to provide an example?

I suppose I understand what you're saying that boolean should be equal to a union of literal types, but that's not what I expect to happen when I write the word boolean (as opposed to true|false). When I write boolean I expect it to behave equally to the other built-in atomic types, since it is a built-in atomic type (the fact that it happens to have only two possible values is irrelevant I feel).

The other thing that feels inconsistent is that (at least in strict mode) boolean behaves differently to everything else because it's the only keyword that implies a union type.

Edit: fixed typos.

[ahejlsberg]

@Griffork I'd change TypeWriteQuery<T> to something like:

type TypeWriteQueryDistributed<T> =
    T extends Array<infer U> ? Partial<ArrayUpdate<U>> :
    T extends object ? WriteQuery<T> :
    T extends null | undefined ? T :
    never;

type Primitives<T> = T extends object | null | undefined ? never : T;

export type TypeWriteQuery<T> =
    TypeWriteQueryDistributed<T> |
    (Primitives<T> extends never ? never : Partial<UpdateValue<Primitives<T>>>);