🤔 requirements

Implement a paradigm ChangeArgument

any[]>, for the given function type Fn, returns a new function G.

The parameter type of G is Fn minus the First item, and the return type of G is Fn plus the value of type First at the end

Type Fn = (a: number, b: string) => [number] type Result = ChangeArgument<Fn> Number) => [number, string] type Fn = () => [number] type Result = ChangeArgument<Fn>Copy the code

📖 knowledge

  1. inferIt first appeared herePRIn, indicates inextendsThe type variable to be inferred in a conditional statement.
  2. Tuple types allow you to express an array with a fixed number of elements whose types are known, but need not be the same. For example, you may want to represent a value as a pair of a string and a number:
  3. TypeScript, like JavaScript, allows you to work with arrays of values. Array types can be written in one of two ways. In the first, you use the type of the elements followed by [] to denote an array of that element type:
  4. When a rest parameter has a tuple type, the tuple type is expanded into a sequence of discrete parameters. For example the following two declarations are equivalent:
  5. When a function call includes a spread expression of a tuple type as the last argument, the spread expression corresponds to a sequence of discrete arguments of the tuple element types.

🔗 Knowledge link

  1. Infer:
  2. Tuple and Array
  3. Rest Parameters and Spread expression
  4. Get the array length

😢 questions & Answers

  1. Change-Argument
  2. answer

🍗 scenario

type FirstArgument<T extends (... args: any[]) => any> = Parameters<T>[0] type RestArgument<T extends (... args: any[]) => any> = Parameters<T> extends [ first: any, ...rest: infer R ] ? R : []; const bindFunction = <T extends (... args: any[]) => any,>(fn: T, firstArgs: FirstArgument<T>) => { return (... restArgs: RestArgument<T>) => { fn(firstArgs, ... restArgs) } } const demo = bindFunction((name: string, age: number) => { console.log(name + age)}, "123") demo(123)Copy the code