Ensuring that functions retain their original signature when being executed in TypeScript

Question

Ensuring that functions retain their original signature when being executed in TypeScript

In my application, I have a method that can accept various types of functions. One specific function called constant exists, and I need to prevent any functions with the same signature from being passed as arguments - all without changing the parameter type of the method.

To achieve this, I made an attempt using instanceof

const constant = (number) => number

class Context {
    execute(fn: (...args?: any) => any) {
        if (fn instanceof constant)
            return false
    }
}

However, it seems that the instanceof operation does not work between functions in this case.

What methods or techniques are there for checking at runtime if a function shares the same signature as another function in TypeScript?

It's worth noting that although I'm asking for a TypeScript solution, vanilla JavaScript approaches would also be suitable if TypeScript cannot provide a more elegant solution.

javascript typescript types

Answer 1

Answer №1

When discussing runtime, it's important to consider TypeScript. For example, you can analyze the function pattern as a string, although this approach may be considered somewhat unconventional. It begs the question of your ultimate goal, especially when utilizing TypeScript, where running dynamic functions may not be advisable. Nevertheless, below is an illustration of how your resulting JavaScript code might appear.

const constant = (number) => number

class Context {
    execute(fn) {        
         if (typeof fn === 'function' && /\(number\) => /.test(fn.toString())) {
           console.log('Function has same pattern as constant');
         }
    }
}

const inst = new Context();
inst.execute(constant);

Here is the TypeScript version:

const constant = (number: number) => number

class Context {
    execute(fn: (args?: any) => any): void {
        if (typeof fn === 'function' && /\(number\) => /.test(fn.toString())) {
           console.log('Function has same pattern as constant');
         }
    }
}


const inst = new Context();
inst.execute(constant); // true
inst.execute((notNumber: number) => notNumber); // not true

Answer 2

When discussing runtime, it's important to consider TypeScript. For example, you can analyze the function pattern as a string, although this approach may be considered somewhat unconventional. It begs the question of your ultimate goal, especially when utilizing TypeScript, where running dynamic functions may not be advisable. Nevertheless, below is an illustration of how your resulting JavaScript code might appear.

const constant = (number) => number

class Context {
    execute(fn) {        
         if (typeof fn === 'function' && /\(number\) => /.test(fn.toString())) {
           console.log('Function has same pattern as constant');
         }
    }
}

const inst = new Context();
inst.execute(constant);

Here is the TypeScript version:

const constant = (number: number) => number

class Context {
    execute(fn: (args?: any) => any): void {
        if (typeof fn === 'function' && /\(number\) => /.test(fn.toString())) {
           console.log('Function has same pattern as constant');
         }
    }
}


const inst = new Context();
inst.execute(constant); // true
inst.execute((notNumber: number) => notNumber); // not true

Answer 3

Answer №2

Performing a check at runtime is not possible due to the availability of typings only at compile time. However, you can enforce a constraint using a conditional type to reject any functions with the signature

const constant: (number: number) => number

by setting their type to never.

const constant = (number: number) => number;

type ForbiddenSignature = typeof constant;
//   ^? type ForbiddenSignature = (number: number) => number

class Context {
  execute<T>(fn: T extends ForbiddenSignature ? never : T) {
    // implementation
  }
}

const context = new Context();
context.execute(constant);
//              ~~~~~~~~ Argument of type '(number: number) => number'
//                       is not assignable to parameter of type 'never'.
context.execute((x: string) => {}); // works
context.execute((x: number) => {}); // works
context.execute(() => {}); //works
context.execute((x: number) => 0); // error
//              ~~~~~~~~~~~~~~~~ Argument of type '(x: number) => number'
//                               is not assignable to parameter of type 'never'.

TypeScript Playground

Answer 4

Performing a check at runtime is not possible due to the availability of typings only at compile time. However, you can enforce a constraint using a conditional type to reject any functions with the signature

const constant: (number: number) => number

by setting their type to never.

const constant = (number: number) => number;

type ForbiddenSignature = typeof constant;
//   ^? type ForbiddenSignature = (number: number) => number

class Context {
  execute<T>(fn: T extends ForbiddenSignature ? never : T) {
    // implementation
  }
}

const context = new Context();
context.execute(constant);
//              ~~~~~~~~ Argument of type '(number: number) => number'
//                       is not assignable to parameter of type 'never'.
context.execute((x: string) => {}); // works
context.execute((x: number) => {}); // works
context.execute(() => {}); //works
context.execute((x: number) => 0); // error
//              ~~~~~~~~~~~~~~~~ Argument of type '(x: number) => number'
//                               is not assignable to parameter of type 'never'.

TypeScript Playground

Ensuring that functions retain their original signature when being executed in TypeScript

Answer №1

Answer №2

Similar questions

Load the page's content gradually, without needing to wait for all the content to be fully loaded

AngularJS ng-repeat: displaying a list of filtered outcomes exclusively

The CSS ::after selector is experiencing a decrease in animation speed

The Jquery animate function is not compatible with the transform property

Having trouble accessing `event.target.value` when selecting an item from the autocomplete feature in Material-UI with the

"Incorporating text input from a textbox into a <ul> list

A guide on assigning specific (x, y) coordinates to individual IDs within the tree structure

Combining Arrays of Javascript Objects with Different Data Types

Error loading GLTF file

jQuery's AJAX feature fails to identify the newly modified div classes

Updating JSON when the color changes in Go.js can be achieved by implementing event listeners and

Tips on how to dynamically uncheck and check the Nebular checkbox post-rendering

Error encountered while compiling an Asp.Net Core project due to exceeding the maximum allowable path length in the

Tips for updating the color of buttons after they have been selected, along with a question regarding input

Loading animation reminiscent of a whirlpool, similar to the movement

Ways to determine cleanliness or filthiness in an Angular 5 modal form?

In JavaScript, private variables are not included in the JSON.stringify output

Increasing the height of a jQuery div element and displaying image captions when hovering over them

Encountering obstacles when trying to implement mongoose virtuals in a TypeScript environment

Customizing vertex sizes in BufferGeometry for diverse shapes