Tukukkk

This is a continuation of an issue resolved here: Avoid typescript casting inside a switch
Using that I have set up types like this:

interface FooInterface {

  foo: number,

  type: "FOO"

}



interface BarInterface {

  bar: number,

  type: "BAR"

}



interface FooBarTypeMap {

  FOO: FooInterface;

  BAR: BarInterface;

}



type FooBarTypes = "FOO" | "BAR";



export type FooBarAction<T extends FooBarTypes> = T extends any ? {

  type: T;

  data: FooBarTypeMap[T];

} : never;





//I want to use this to create a function which returns a FooBarAction, of either type. But the following code fails on typings:   



const createFooBarAction = <T extends FooBarTypes>(fooBarData: FooBarTypeMap[T]): FooBarAction<T> => ({

  type: fooBarData.type,

  data: fooBarData

});

Changing either input or return value to any works, but obviously I would like to avoid that. I tried creating a AllFooBarInterfaces which FooInterface and BarInterface extends like this:

// Seems to not have any effect, but it might be a good practice anyway.

interface AllFooBarInterfaces<T extends FooBarTypes> {

  type: T

}



interface FooInterface extends AllFooBarInterfaces<"FOO">{

  foo: number,

}



interface BarInterface extends AllFooBarInterfaces<"BAR">{

  bar: number,

}

While I can do changes in the above definition of interfaces and types, I still need to support the case asked in the original question, which is included below for easy access.

const doSomthingBasedOnType = (action: FooBarAction<FooBarTypes>): void => {

  switch (action.type) {

    case "FOO":

      FooAction(action);

  }

};



const FooAction = (action: FooBarAction<"FOO">): void => {

  //do something with action.data

};

You implementation will not work because Typescript does not allow the assignment of values to places where a type with unresolved generic parameters is expected. The best solution, to preserve call site behavior is to add an overload that has the generic type parameter, and an sperate implementation signature, that is a little less type safe but that allows us to actually implement the function:

function createFooBarAction <T extends FooBarTypes>(fooBarData: FooBarTypeMap[T]): FooBarAction<T>

function createFooBarAction (fooBarData: FooBarTypeMap[FooBarTypes]): FooBarAction<any> {

  return {

    type: fooBarData.type,

    data: fooBarData

  };

}

Note the use of any in the return type. This is unfortunately required. Returning
FooBarAction<FooBarTypes> will not work since the returned object will be typed as { type: FooBarTypes; data: FooInterface | BarInterface; } while FooBarAction<FooBarTypes> is resolved to { type: "FOO"; data: FooInterface; } | { type: "BAR"; data: BarInterface; }.

We could use a switch in this case as well to convince the compiler that out types are correct, but since each branch of the switch will have the same code, it seems like overkill :

function createFooBarAction <T extends FooBarTypes>(fooBarData: FooBarTypeMap[T]): FooBarAction<T>

function createFooBarAction (fooBarData: FooBarTypeMap[FooBarTypes]): FooBarAction<FooBarTypes> {

  switch (fooBarData.type) {

    case "FOO": return { type:fooBarData.type, data: fooBarData }

    case "BAR": return { type:fooBarData.type, data: fooBarData }

  }

}