Generic not inferred inside mapped type parameter

[OliverJAsh]

TypeScript Version: 3.2.2

Search Terms: generic inference {} createStructuredSelector mapped types

Code

type Selector<S, R> = (state: S) => R;

declare function createStructuredSelector<S, T>(
    selectors: { [K in keyof T]: Selector<S, T[K]> },
): Selector<S, T>;

type State = { foo: number };
declare const mySelector: Selector<State, boolean>;

// Workaround: use explicit generics
// const result = createStructuredSelector<State, { mySelector: boolean }>({

// `State` generic incorrectly inferred as `{}`.
const result = createStructuredSelector({
    // Unexpected type error under `strictFunctionTypes` due to bad inference (above)
    mySelector,
});

result;

[Kingwl]

An interesting thing:

type Selector<S, R> = (state: S) => R;

declare function createStructuredSelector<S, T, L extends keyof T = keyof T>(
    selectors: {
        [K in L]: Selector<S, T[K]>
    }
): Selector<S, T>;

type State = { foo: number };
declare const mySelector: Selector<State, boolean>;

// result => Selector<State, {}>
const result = createStructuredSelector({
    mySelector
});

[Kingwl]

i have already fixed the case whitch @OliverJAsh has provided, but i have no idea about mine case

[ilyaulyanov]

Any updates on this? I'd rather avoid duplication in generics

[RyGuy101]

One workaround is to use function currying so you only have to specify the first parameter:

// I put this in a file called 'reduxUtils.ts'
import * as Reselect from "reselect";

export function createStructuredSelector<S>() {
  return function<T>(
    selectors: { [K in keyof T]: Reselect.Selector<S, T[K]> }
  ) {
    return Reselect.createStructuredSelector<S, T>(selectors);
  };
}

Usage:

const result = createStructuredSelector<State>()({ mySelector });

[borispinus]

now it's unknown, not {}. Is it typescript bug that in this case unknown and State are not compatible? Or expected behavior?

[Andarist]

The interesting thing is that if we add more parameters to Selector (even non-generic ones) then an inline version that doesn't use those parameters can be inferred OK:

type Selector<S, R> = (state: S, meta: number) => R;

declare function createStructuredSelector<S, T>(selectors: {
  [K in keyof T]: Selector<S, T[K]>;
}): Selector<S, T>;

type State = { foo: number };

declare const mySelector: Selector<State, boolean>

const result1 = createStructuredSelector({
  // Type 'Selector<State, boolean>' is not assignable to type 'Selector<unknown, boolean>'.
  //   Type 'unknown' is not assignable to type 'State'.(2322)
  mySelector: mySelector,
});

const result2 = createStructuredSelector({
  // ok
  mySelector: (state: State) => true,
});

result2;
// ^? const result: Selector<State, { mySelector: boolean; }>

export {};

If we just remove meta from Selector (that stays unused throughout this whole example) then both fail.