#Recursive generic type in an array

12 messages · Page 1 of 1 (latest)

hoary orbit
#

Lets say I have 3 types:

type AllowedAnimals = "dog" | "cat";

type AnimalFoodMap = {
  name: SomeDogFoodType;
  cat: SomeCatFoodType;
}

type Config<T extends AllowedAnimals> = {
  animal: T;
  food: AnimalFoodMap[T];
}

When creating a single object the type of food gets inferred propperly:

const dog: Config = {
  animal: "dog",
  food: {} // <- type is correctly inferred as "SomeDogFoodType"
}

This all works fine like expected, the issue arrises when I want to make the Config type recursive by accepting children:

type Config<T extends AllowedAnimals> = {
  animal: T;
  food: AnimalFoodMap[T];
  children?: Config[];
}

At this point the type inferrence for the prop food stops working and instead it becomes a union of type SomeDogFoodType | SomeCatFoodType:

const myConfig: Config = {
  animal: "dog",
  food: {} <- correctly inffered as "SomeDogFoodType"
  children: [
    {
      animal: "cat",
      food: {} <- inferred as "SomeDogFoodType | "SomeCatFoodType"
    }
  ]
}

My goal is to infer the type of food correctly for each item in the array of children no matter how far down it is nested. What is the best way to achieve this?

Hope the example was clear, if not i can provide some others.

vapid blade
#

do you want the children to have the same type as the parent?

hoary orbit
#

the animal prop should be able to be any of the AllowedAnimals type based on which the correct food type is inferred for that specific child

scarlet marlinBOT
#
that_guy977#0
Playground Link

Preview:```ts
type AllowedAnimals = "dog" | "cat";

type AnimalFoodMap = {
dog: { dog: string };
cat: { cat: string };
}

type Config<T extends AllowedAnimals = AllowedAnimals> = T extends T ? {
animal: T;
food: AnimalFoodMap[T];
children?: Config[];
} : never
...```

You can choose specific lines to embed by selecting them before copying the link.
hoary orbit
#

I will try this out in my codebase (example was just a simpliefied version), i'll report back soon

#

but it looks promising, thnx for the help

vapid blade
#

the T extends T lets you create a discriminated union from the input

#

!hb disc

scarlet marlinBOT
vapid blade
#

the satisfies Config isn't super important, you could use a type annotation as well

#

it might help depending on your usecase though

hoary orbit
#

@vapid blade it worked! thanks alot. Was stuck hours on this issue and couldnt find alot of info online (probally used the wrong search terms).