Ensure that both functions share identical signatures by utilizing types exclusively

Question

Ensure that both functions share identical signatures by utilizing types exclusively

Is it possible to enforce the copy function to extend the original function, even when the parameters of the fnGenerator are in reverse order?

Can this be achieved?

function fnGenerator<Original extends Copy, Copy extends Function>(copy:Copy,original:Original){}

function original(props:{a?:number,z:number}):number { return 2}
function copy(props:{a:number}):number { return 1}

// Currently, `original` is facing compilation errors instead of `copy`
fnGenerator(copy,original)

Real usecase:

function fallback<OriginalFn extends Function>(props: {fallback:OriginalFn}) {
  return function (target: any,
   propertyKey: string, 
   descriptor: Omit<PropertyDescriptor,'value'> & { value?: OriginalFn}
) {
    return descriptor
  };
}

class MyClass1 {
  // I expect a compilation error but it works 
  @fallback({fallback: (props: {x:number,z:number})=>{ return 0} })
  static method1(pros:{x:number, z?: number}):number {
    return 1
  }
}

typescript typescript-generics

Answer 1

Answer №1

Wow, that definitely presented a challenge. Read the full discussion here.

Check out my initial solution. Unfortunately, it didn't work as expected (refer to the link for the playground)

At first, I suspected a typescript bug.

Turns out it's just method parameter bivariance.

Here's a workaround solution to tackle parameter bivariance.:

function fallback2<MethodArgs extends unknown[],MethodReturn,FallbackFn extends (...args: MethodArgs) => MethodReturn>(props: { fallbackFn: FallbackFn }) {
  return function(target: any,
    propertyKey: string,
    descriptor: TypedPropertyDescriptor<(...args: MethodArgs) => MethodReturn>
  ) {
    // implement fallback logic...
    return descriptor
  };
}

class MyClass1 {
  // I expect a compilation error because FallbackFn does not extend Method1Fn
  @fallback2({ fallbackFn: (props: { x: number,y:number }):number => { return 0 } }) // works! why??
  static method1Class1(pros: {x: number }): number {
    return 1
  }

  @fallback2({ fallbackFn: ():number => { return 0 } }) // works! why??
  static method1Class2(x:number): number {
    return 1
  }

      // I expect a compilation error because FallbackFn does not extend Method1Fn
  @fallback2({ fallbackFn: (y:number,z:number):number => { return 0 } }) // works! why??
  static method1Class3(x:number): number {
    return 1
  }

  @fallback2({ fallbackFn: (y:number,z?:number):number => { return 0 } }) // works! why??
  static method1Class4(x:number): number {
    return 1
  }
}

Answer 2

Wow, that definitely presented a challenge. Read the full discussion here.

Check out my initial solution. Unfortunately, it didn't work as expected (refer to the link for the playground)

At first, I suspected a typescript bug.

Turns out it's just method parameter bivariance.

Here's a workaround solution to tackle parameter bivariance.:

function fallback2<MethodArgs extends unknown[],MethodReturn,FallbackFn extends (...args: MethodArgs) => MethodReturn>(props: { fallbackFn: FallbackFn }) {
  return function(target: any,
    propertyKey: string,
    descriptor: TypedPropertyDescriptor<(...args: MethodArgs) => MethodReturn>
  ) {
    // implement fallback logic...
    return descriptor
  };
}

class MyClass1 {
  // I expect a compilation error because FallbackFn does not extend Method1Fn
  @fallback2({ fallbackFn: (props: { x: number,y:number }):number => { return 0 } }) // works! why??
  static method1Class1(pros: {x: number }): number {
    return 1
  }

  @fallback2({ fallbackFn: ():number => { return 0 } }) // works! why??
  static method1Class2(x:number): number {
    return 1
  }

      // I expect a compilation error because FallbackFn does not extend Method1Fn
  @fallback2({ fallbackFn: (y:number,z:number):number => { return 0 } }) // works! why??
  static method1Class3(x:number): number {
    return 1
  }

  @fallback2({ fallbackFn: (y:number,z?:number):number => { return 0 } }) // works! why??
  static method1Class4(x:number): number {
    return 1
  }
}

Ensure that both functions share identical signatures by utilizing types exclusively

Answer №1

Similar questions

Tips on joining property name in typescript

Is it possible to set the initial value of useState() as null and later assign it an object value?

What mistakes am I making with Typescript and jquery-ui?

Issue detected in loading ./styles.css in Angular 6

What could be causing the OnInit lifecycle hook to fail to execute properly?

What is the importance of always catching errors in a Promise?

Tips for navigating through a nested JSON object with loops

Clicking on the <Link to=URL> in a React application built with Typescript and Redux triggers the disappearance of the component

Defining types for functions that retrieve values with a specified default

The anticipated data originates from the 'style' attribute, which is formally noted within the 'IntrinsicAttributes & TextInputProps & RefAttributes<TextInput>' type

Troubleshooting issue: Angular Typescript object array filter functionality malfunctioning

Angular failing to retrieve URL parameters correctly

Importing a JSON or JSONC file into a vite/typescript project can be easily done

When I utilize the redux connect function, the class information in my IDE (PhpStorm/WebStorm) seems to disappear

Tips for excluding test files in next.js when building

Creating a data type restricted to utilizing property names exclusively from a specified string union:

Listening for value changes on a reactive form seems to be a challenge for me

What is the syntax for declaring a list of JSON objects in TypeScript?

Monorepo with Yarn workspaces using Typescript and Node.JS project encounters "module not found" error while running nodemon

The function does not yield any result