Creating function templates using immutable objects as parameters

Question

Creating function templates using immutable objects as parameters

I am currently working on generating function signatures based on a generic readonly object that is inputted. Take a look at the following example:

type input0 = ReadOnly<{x: number, y: number, z: number}>

// generate this type from input0 as a generic
type input0signature = (x: number, y: number, z: number) => void

Here's another example for better understanding:

type input1 = ReadOnly<{id: number, age: number}>

// generate this type from input1 as a generic
type input1signature = (id: number, age: number) => void

It's important to point out that the order and names of the arguments in the generated function signatures must match exactly with those in the inputted type. Also, I specifically do not want to create signatures using spread operators (like tuples or arrays) for the arguments, nor do I want the inputted type to be used as an argument directly, as shown here:

type input1 = ReadOnly<{id: number, age: number}>

// I do NOT want signatures to use the spread operator
type input1signatureTuple = (...args: [number, number]) => void

// And also NOT like this
type input1signatureObject = (arg: input1) => void

Is it possible to achieve this functionality in TypeScript?

typescript typescript-typings typescript-generics

Answer 1

Answer №1

If you happen to come across this later on, I've come up with a creative workaround for the previous issue - It's not flawless but does the job well enough for what I needed. Here's a link to the complete playground solution.

To begin, you need to extract the keys of the inputted object into a tuple. Next, you map the created tuple into a dummy interface (let's call it "Argument", "Property", etc.), which includes two generics: "name" and "type", extending all potential argument types.

// Define the type you want to derive the function signature for
type BaseType = Readonly<{ x: number, y: number, z: number }>

// Extract object keys into a tuple
type BaseTypeTuple = UnionToTuple<keyof BaseType>

// Create a dummy interface that extends all possible types of function arguments
// In this example, only numbers are used
interface Arg<_name extends string, _type> extends Number {}

// Map key names and types to a tuple of the dummy interface
type BaseTypeArgs<T, K extends Array<keyof T>> = {
    [index in keyof K]: K[index] extends string 
        ? Arg<K[index], T[K[index]]>
        : never
}

// The resulting type should be: (args_0: Arg<"x", number>, args_1: Arg<"y", number>, args_2: Arg<"z", number>) => void
// Ensure correct ordering and types
const testFn = (...args: BaseTypeArgs<BaseType, BaseTypeTuple>) => {}

An interface is utilized because Typescript maintains interface aliases, allowing you to incorporate the "name" of the function arguments without worrying about them being removed. Essentially, your IDE's intellisense will typically include the name and generics of your interface in every instance it's used in.

Answer 2

If you happen to come across this later on, I've come up with a creative workaround for the previous issue - It's not flawless but does the job well enough for what I needed. Here's a link to the complete playground solution.

To begin, you need to extract the keys of the inputted object into a tuple. Next, you map the created tuple into a dummy interface (let's call it "Argument", "Property", etc.), which includes two generics: "name" and "type", extending all potential argument types.

// Define the type you want to derive the function signature for
type BaseType = Readonly<{ x: number, y: number, z: number }>

// Extract object keys into a tuple
type BaseTypeTuple = UnionToTuple<keyof BaseType>

// Create a dummy interface that extends all possible types of function arguments
// In this example, only numbers are used
interface Arg<_name extends string, _type> extends Number {}

// Map key names and types to a tuple of the dummy interface
type BaseTypeArgs<T, K extends Array<keyof T>> = {
    [index in keyof K]: K[index] extends string 
        ? Arg<K[index], T[K[index]]>
        : never
}

// The resulting type should be: (args_0: Arg<"x", number>, args_1: Arg<"y", number>, args_2: Arg<"z", number>) => void
// Ensure correct ordering and types
const testFn = (...args: BaseTypeArgs<BaseType, BaseTypeTuple>) => {}

An interface is utilized because Typescript maintains interface aliases, allowing you to incorporate the "name" of the function arguments without worrying about them being removed. Essentially, your IDE's intellisense will typically include the name and generics of your interface in every instance it's used in.

Creating function templates using immutable objects as parameters

Answer №1

Similar questions

Utilizing the date pipe in Angular2 to format multiple dates in an array

The Angular 2 view will remain unchanged until the user interacts with a different input box

What is the best way to assign the value of "this" to a variable within a component using Angular 2 and TypeScript?

Instructions on utilizing interpolation to transfer a value as an argument to a function

Combining TypeScript into HTML resulted in an error: Uncaught ReferenceError clickbutton is not defined

Dynamic useReducer in Typescript allows for flexible state management by

Function returning promise asynchronously, but caller function failing to resolve the promise

WebStorm encountering TypeScript error with "nullish coalescing operator"

Accessing data retrieved from an API Subscribe method in Angular from an external source

What is the process for sending a successful status code to the front end using node.js?

Limiting an interface to certain keys within a combination of types

Leveraging Class Types with Generics

changing an array into json format using TypeScript

Issue with Angular: RouterLinkActive fails to work properly with formControlName

Create a TypeScript type that requires an object to contain at least one of a particular set of keys

What is the best way to change `props.children` into a JSX element?

What is the most effective method for integrating Typedoc documentation into Confluence?

Unable to install vue-property-decorator

Utilizing React MUI Autocomplete to Save Selected Items

What is the best way to retrieve a plus sign from a URL parameter?