Determining the accurate return type of a function based on a type map

Question

Determining the accurate return type of a function based on a type map

I have a task where a function is needed to return the correct type based on a key-type mapping it has access to.

Here's a simplified example of what I'm working on. Almost there, but seems like something is missing.

Note: This is intended for a library and user-provided types are unknown.

type Plane = {
    name: string;
    wings: number;
};

type Car = {
    name: string;
    wheels: number;
};

type Vehicles = {
    cars: Car;
    planes: Plane;
};

type TypeMap = { [key: string]: any };

type Mapper<VehicleMapType extends TypeMap = TypeMap> = {
    getVehicle<
        VehicleType extends
            | Extract<keyof VehicleMapType, string>
            | never = Extract<keyof VehicleMapType, string>
    >(
        type: VehicleType
    ): VehicleMapType[VehicleType];
};

const mapper: Mapper<Vehicles> = null;

const vehicle1 = mapper.getVehicle('cars');
// This outputs a Car!
console.log(vehicle1);

const getVehicles = <
    VehicleMapType extends TypeMap = TypeMap,
    VehicleType extends Extract<keyof VehicleMapType, string> | never = Extract<
        keyof VehicleMapType,
        string
    >
>(
    type: VehicleType
): VehicleMapType[VehicleType] => {
    return null;
};

const vehicle2 = getVehicles<Vehicles>('cars');
// Need help to get just a Car instead of a Car or a Plane?
console.log(vehicle2);

Thanks!

Edit

In addition to that, we're encountering an issue with the Mapper implementation as evident from this TS Playground

typescript typescript-generics

Answer 1

Answer №1

To properly invoke the function, you must provide both generics (in your case, you only provided Vechicles), or

utilize a functional abstraction to deduce the types, as shown below:

TS Playground

type StringKeys = Record<string, any>;

type Named = { name: string };
type Plane = Named & { wings: number };
type Car = Named & { wheels: number };

type Vehicles = {
  cars: Car;
  planes: Plane;
};

type Mapper<T extends StringKeys> = {
  getVehicle<K extends keyof T>(type: K): T[K];
};

const mapper: Mapper<Vehicles> = {
  getVehicle (type) {
    const vechicles: Vehicles = {
      cars: {name: 'a car', wheels: 4},
      planes: {name: 'a plane', wings: 2},
    };
    const result = vechicles[type];
    if (result) return result;
    throw new Error('unknown vehicle type');
  }
};

const vehicle1 = mapper.getVehicle('cars'); // Car


// Generic functional abstraction:

const pickFrom = <T extends StringKeys>(o: T): <K extends keyof T>(key: K) => T[K] => {
  return key => o[key];
};

declare const vehicles: Vehicles;
const getVehicles = pickFrom(vehicles);
const vehicle2 = getVehicles('cars'); // Car

Answer 2

To properly invoke the function, you must provide both generics (in your case, you only provided Vechicles), or

utilize a functional abstraction to deduce the types, as shown below:

TS Playground

type StringKeys = Record<string, any>;

type Named = { name: string };
type Plane = Named & { wings: number };
type Car = Named & { wheels: number };

type Vehicles = {
  cars: Car;
  planes: Plane;
};

type Mapper<T extends StringKeys> = {
  getVehicle<K extends keyof T>(type: K): T[K];
};

const mapper: Mapper<Vehicles> = {
  getVehicle (type) {
    const vechicles: Vehicles = {
      cars: {name: 'a car', wheels: 4},
      planes: {name: 'a plane', wings: 2},
    };
    const result = vechicles[type];
    if (result) return result;
    throw new Error('unknown vehicle type');
  }
};

const vehicle1 = mapper.getVehicle('cars'); // Car


// Generic functional abstraction:

const pickFrom = <T extends StringKeys>(o: T): <K extends keyof T>(key: K) => T[K] => {
  return key => o[key];
};

declare const vehicles: Vehicles;
const getVehicles = pickFrom(vehicles);
const vehicle2 = getVehicles('cars'); // Car

Determining the accurate return type of a function based on a type map

Answer №1

Similar questions

Styling map controls in Google Maps and React

D3 event: Latest in Type Definitions for Version 6 and Beyond

Compiler is unable to comprehend the conditional return type

Prefix each type within a string union with a specific word

The Angular template is throwing an error stating that c_r1.getCatType is not a valid function

Issue with Hooks (Batched update cycle) - error code TS6133: Unused declaration of '' is detected and not being utilized

Encountering the following error message: "E11000 duplicate key error collection"

Capture a screenshot with Puppeteer at a random URL stop

tips on waiting for the outcome of an http request (synchronous http request, utilizing http request as a promise)

Handling Errors in Angular 4

Leveraging Angular 2 to retrieve information from mongoDB

Unlocking the power of URL manipulation in Fastify using Node.js

Function generation using TypeScript

I'm curious if it's possible to set up both Tailwind CSS and TypeScript in Next.js during the initialization process

pertains to a specific numerical quantity, but is currently being utilized as a category in this context

How can I utilize regex to change the background color of a specific character in a react/typescript application?

Exploration of narrowing union types in React with TypeScript

Identifying and handling errors in the outer observable of an RXJS sequence to manage

Ensuring seamless collaboration between Typescript node modules

TypeError: Unable to access the 'classify' property of an object that has not been defined (please save the ml5.js model first)