boolean in recursive generic inferred as any (string and number work correctly) #29477

benneq · 2019-01-18T09:33:25Z

TypeScript Version: 3.2.4 (also happened with 3.2.2, no information about prior versions)

Search Terms:
generic(s), boolean, infer(red), any

Code
I've removed as much of the type definitions as possible while still getting the error.
In the test code you can see, that the error happens somewhere in the recursive part.
I've included the same 2 cases for string and number, too (where they work). the only issue comes with type boolean.

declare function spected<INPUT, SPEC extends SpecValue<INPUT> = SpecValue<INPUT>>(spec: SPEC, input: INPUT): any;

export type Predicate<INPUT> = (value: INPUT) => boolean

export type SpecValue<INPUT> =
    INPUT extends {[key: string]: any}
        ? {[key in keyof INPUT]: SpecValue<INPUT[key]>}
        : Predicate<INPUT> | ((value: INPUT) => Predicate<INPUT>);
        
// TEST CODE #1:
const data = {
    str1: "",
    str2: "",
    number1: 0,
    number2: 0,
    boolean1: true,
    boolean2: true
}

const res = spected<typeof data>(
    {
        str1: (value) => false,
        str2: (value) => (value) => false,
        number1: (value) => false,
        number2: (value) => (value) => false,
        boolean1: (value) => true, // ERROR: value is of type any
        boolean2: (value) => (value) => true // ERROR: value is of type any (both)
    },
    data
);

// TEST CODE #2:
spected((value) => false, "");
spected((value) => (value) => false, "");
spected((value) => false, 0);
spected((value) => (value) => false, 0);
spected((value) => false, true); // works as expected
spected((value) => (value) => false, true); // works as expected

Expected behavior:
boolean should behave exactly the same as string and number

Actual behavior:
boolean behaves special

Related Issues:
none yet?

The text was updated successfully, but these errors were encountered:

jack-williams · 2019-01-18T10:24:07Z

The problem stems from the fact that boolean is actually a union type true | false, and your conditional type SpecValue distributes over union. Compare these types to see where the problem comes from:

// type N = Predicate<number> | ((value: number) => Predicate<number>)
type N = SpecValue<(typeof data)["number1"]>;
// type B = Predicate<false> | ((value: false) => Predicate<false>) | Predicate<true> | ((value: true) => Predicate<true>)
type B = SpecValue<(typeof data)["boolean1"]>;

This definition of SpecValue gives the behaviour you want, I think.

export type SpecValue<INPUT> =
    [INPUT] extends [object]
        ? {[key in keyof INPUT]: SpecValue<INPUT[key]>}
        : Predicate<INPUT> | ((value: INPUT) => Predicate<INPUT>);

// type B = Predicate<boolean> | ((value: boolean) => Predicate<boolean>)
type B = SpecValue<(typeof data)["boolean1"]>;

Tag for searching purpose: distributive conditional type trouble

benneq · 2019-01-18T10:45:59Z

Yes, it looks like it works for that small example. But I still have trouble with my real code...
There I have to distinguish between "key-value objects", "arrays", and "primitives".

I'm not really sure what [INPUT] extends [object] does. Looks like "tuple with one element 'INPUT' extends tuple with one element of type object". But the object type also includes arrays.

Why can't I use it the other way around?

export type SpecValue<INPUT> =
    INPUT extends (string | number | true | false | boolean)
        ? Predicate<INPUT> | ((value: INPUT) => Predicate<INPUT>)
        : {[key in keyof INPUT]: SpecValue<INPUT[key]>}

jack-williams · 2019-01-18T11:02:50Z

I'm not really sure what [INPUT] extends [object] does.

If you have a conditional type A extends B ? C : D, and A is a type parameter, the conditional type gets marked as distributive. Wrapping the check and extends type in [] is a way to turn that off.

[A] extends [B] ? C : D is a non distributive form of A extends B ? C : D.

I use object instead of { [key: string]: any } because it is shorter.

You can apply the same trick that; seems to work for me:

export type SpecFunction<INPUT, ROOTINPUT = any> = [INPUT] extends [ReadonlyArray<infer U>]
    ? (value: INPUT) => ReadonlyArray<SpecArray<U, ROOTINPUT>>
    : [INPUT] extends [object]
        ? (value: INPUT) => SpecObject<INPUT, ROOTINPUT>
        : (value: INPUT) => SpecArray<INPUT, ROOTINPUT>;

export type SpecObject<INPUT, ROOTINPUT = any> = Partial<{[key in keyof INPUT]: SpecValue<INPUT[key], ROOTINPUT>}>

export type SpecValue<INPUT, ROOTINPUT = any> = [INPUT] extends [ReadonlyArray<any>]
    ? SpecArray<INPUT, ROOTINPUT> | SpecFunction<INPUT, ROOTINPUT>
        : [INPUT] extends [object]
            ? SpecArray<INPUT, ROOTINPUT> | SpecFunction<INPUT, ROOTINPUT> | SpecObject<INPUT, ROOTINPUT>
            : SpecArray<INPUT, ROOTINPUT> | SpecFunction<INPUT, ROOTINPUT>;

benneq · 2019-01-18T11:07:43Z

Yes, this works great! Thank you!

I didn't apply this trick to the Arrays. Guess I have to read some more about those distributive types.

But you can only use object instead of { [key: string]: any }, because there's the check for array before.

benneq closed this as completed Jan 18, 2019

benneq mentioned this issue Jan 18, 2019

TypeScript typings busypeoples/spected#105

Open

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

boolean in recursive generic inferred as any (string and number work correctly) #29477

boolean in recursive generic inferred as any (string and number work correctly) #29477

benneq commented Jan 18, 2019 •

edited

Loading

jack-williams commented Jan 18, 2019

benneq commented Jan 18, 2019 •

edited

Loading

jack-williams commented Jan 18, 2019

benneq commented Jan 18, 2019 •

edited

Loading

boolean in recursive generic inferred as any (string and number work correctly) #29477

boolean in recursive generic inferred as any (string and number work correctly) #29477

Comments

benneq commented Jan 18, 2019 • edited Loading

jack-williams commented Jan 18, 2019

benneq commented Jan 18, 2019 • edited Loading

jack-williams commented Jan 18, 2019

benneq commented Jan 18, 2019 • edited Loading

benneq commented Jan 18, 2019 •

edited

Loading

benneq commented Jan 18, 2019 •

edited

Loading

benneq commented Jan 18, 2019 •

edited

Loading