Get type of parameter list of a function (parametersof?)

Search Terms

type of function's parameters list; type of arguments list; tuples;

Suggestion

There are functions a() and b(). Function a() have the same signature (parameters) as function b().
Instead of manually copying list of parameters with their types from b() to a(), there should be a way to assign types of parameters to a() from b().

function a(...args: /* possible syntax starts */ parametersof b /*possible syntax ends*/ ) {
  b(...args)
}

function b (a: string, b: number) { /* ... */}

a('foo', 1) // ok
a('foo', 'bar') // compiler error "Argument of type 'bar' is not assignable to parameter of type 'number'"

parametersof ... should probably return a tuple.

Use Cases

Decorators or simply reusing existing functions:

function a(...args: parametersof b) {
  // ... do some stuff 
  b(...args)
}

API that provides lazy-loaded functions or provides functions based on environment:

import someFunc from './someFunc'
export const someAPI = {

  someFunc, // normal one, we just re-exporting this func

  async lazyFunc(...args: parametersof eagerFunc) { 
    const {eagerFunc} = await import('./eagerFunc') 
    return eagerFunc(...args)
  }, // lazy func. helps to reduce main bundle

  get node() {
    if (runningInNode()) {
      return {
        async nodeFunc(...args: parametersof nodeFunc) {
          const {nodeFunc} = await import('./nodeFunc') 
          return nodeFunc(...args)
        }
      }
    }
  } // here we do not add code, that is supposed to work only in node.js, to frontend bundle)
}

Current workarounds and their faults

function a(a: string, b: number) {
  b(...args)
}

function b (a: string, b: number) {/*...*/}

Above practice have these disadvantages:

When changing b's signature, we also have to change a's one. That is little bit harder maintenance and a window for new errors.
Contradicts with DRY principle

Comparison to tuples

I am aware of new "tuples" feature in TS 3.0, which is great! However using tuples for this use case requires creating new types, while "parametersof" solution will end up in minimum possible amount of code and maximum readability.

Checklist

My suggestion meets these guidelines:

This wouldn't be a breaking change in existing TypeScript / JavaScript code
This wouldn't change the runtime behavior of existing JavaScript code
This could be implemented without emitting different JS based on the types of the expressions
This isn't a runtime feature (e.g. new expression-level syntax)

Anders Hejlsberg (@ahejlsberg)

Somewhere, Anders Hejlsberg (@ahejlsberg) proposed adding the following definition to lib.d.ts:

type Parameters<T> = T extends (... args: infer T) => any ? T : never;

I think this is the right way to go here over a new operator.

If it's useful, here's ReturnType as well:

type ReturnType<T> = T extends (... args: any[]) => infer T ? T : never;

Brian Terlson (@bterlson)

Brian Terlson (@bterlson) thank you for quick response!

My thoughts on the solutions provided by you:

It's soo cryptic. I have to take some time to decode it... this infer thing... and what ternary does actually do. And what is supposed to be T (I guess a function?).
Where can I read more about this solution? I honestly searched, but failed to find. Or maybe can you explain?

P.S. And yes! I forgot about return types, they are also should have some way to be assigned from one func to another.

Nurbol Alpysbayev (@anurbol)

Nurbol Alpysbayev (@anurbol) if it gets added to lib.d.ts you can just use Parameters<some function type> without understanding how it works (much like how Pick or Record work today).

Probably the best resource to understand this stuff is the 2.8 release blog. Parameters and ReturnType are conditional types using the infer keyword in the conditional to tell TS to infer T's argument list or return type respectively.

Also, here's an example of using Parameters:

function foo(a: number, b: string) {
  return true;
}
type p = Parameters<typeof foo>;
// p = [number, string]

Brian Terlson (@bterlson)

Thank you, Brian Terlson (@bterlson)! I love TS even more now! ❤️ And ReturnType (BTW one does not have to add it to lib.d.tsm it is already included in the core lib), fantastic!

Brian Terlson (@bterlson)

Brian Terlson (@bterlson) using TS 3.0.1, it seems like the definition above for Parameters just returns an empty Object type. Ex:

type Parameters<T> = T extends (... args: infer T) => any ? T : never; 
const x: test = (a: number) => 5;
type Params = Parameters<typeof x>;
const a: Params = ['should-not-work']; // works, but shouldn't
function t(...args: Params) {} // does not work, but should work

Yields

[ts] A rest parameter must be of an array type.
type Params = {}

Any ideas on what might be wrong? Or is re-using function argument types for new functions not yet supported?

EDIT: Nevermind, this does work in 3.0. I had a dependency in my test repo that was pulling in the wrong version.

is there any possibility to extract parameter names as well? e.g.

function foo(a: number, b: string) {
  return true;
}
type p = ParametersWithNames<typeof foo>;
// p = { a: number, b: string }

edit: probably I want too much and parameter names don't relate to type system..

Umed Khudoiberdiev (@pleerock)

Umed Khudoiberdiev (@pleerock) There is no way to extract the parameter names to an object type.

Parameter names will however be preserved if you extract form one function and spread to another function:

function foo(x: number, y: number) {

}

//function bar(x: number, y: number): void
function bar(...a: Parameters<typeof foo>) {
    
}

Playground Link

Titian Cernicova-Dragomir (@dragomirtitian)

Thanks Titian Cernicova-Dragomir (@dragomirtitian). That's interesting behavior. However I wanted to create an object type out of parameter names, e.g. { x: number, y: number }

What if you only have one parameter and want that parameter, not an array with that parameter?

function foo(a: number) {
  return true;
}
type p = Parameters<typeof foo>;
// p = number

Diego Julião (@dianjuar)

Diego Julião (@dianjuar)

function foo(a: number) {
  return true;
}
type p = Parameters<typeof foo>[0];

Playground Link

In a similar vein to this, is it possible to first define the args expected and then use them in both functions? For example...

type CommonArgs = {
  a: number;
  b: number;
}

function foo(...a: CommonArgs) {

}

function bar(...a: CommonArgs) {
    
}

It doesn't really make sense in the above snippet alone but what I am interested in is reducing boilerplate when it comes to function overloading. If we want the return type to be narrowed based on an input

// foo can return two different types based upon an input, say a boolean

function foo(a: number, b?: boolean): string | number {
  if (b === false) {
    return a;  // return type is number
  }
  return '' + a;  // return type is string
}

const value = foo(10, false); // <= typeof value: string | number
Math.abs(value); // Argument of type 'string | number' is not assignable to parameter of type 'number'

// this can be solved with
function foo(a: number, b: true): string;
function foo(a: number, b: false): number;
function foo(a: number, b?: boolean) {
  if (b === false) {
    return a;
  }
  return '' + a;
}
const value = foo(10, false); // correctly infers return type as number

This works but is only a trivial number of args, so could be more boilerplate to copy and paste. Is it possible for something like...

type CommonArgs = {
  a: number;
  // c, d, e, etc...
}

function foo(...a: CommonArgs & { b: true }): string
function foo(...a: CommonArgs & { b: false }): number
function foo(a: number, b?: boolean) {
  if (b === false) {
    return a;
  }
  return '' + a;
}

I have attempted using conditional types but have not managed to do so far...

EDIT

Additionally it would be nice to add some type-safety to the function implementation, along the lines of:

type CommonArgs = {
  a: number;
  b?: boolean;
  // c, d, e, etc...
}
type CommonReturnType = string | number;
type CommonFunction = (...a: CommonArgs): CommonReturnType;

function foo(...a: CommonArgs & { b: true }): string
function foo(...a: CommonArgs & { b: false }): number
foo: CommonFunction = function(a: number, b?: boolean) {
  return {}; // compiler identifies this return type is not allowed
}

Bhish (@bhishp)

Bhish (@bhishp)
I think the parameters only exist in value space: They are not keys(string | number) of an object but variables.
Even you get a type like [arg0: string, arg1, number] by writing Parameters<some-function-type>,
the parameter names are lost in the type space.

Bhish (@bhishp)

Bhish (@bhishp) I am curious. Did you find a solution to your latest question concerning spreading the properties of a type as arguments to a function?

Bhish (@bhishp)

Bhish (@bhishp) I am curious. Did you find a solution to your latest question concerning spreading the properties of a type as arguments to a function?

I'm afraid not, sorry

Navigation Menu

Repository navigation

Get type of parameter list of a function (parametersof?) #26019

Search Terms

Suggestion

Use Cases

Current workarounds and their faults

Comparison to tuples

Checklist

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Get type of parameter list of a function (parametersof?) #26019

Description

Search Terms

Suggestion

Use Cases

Current workarounds and their faults

Comparison to tuples

Checklist

Activity

bterlson commented on Jul 27, 2018

anurbol commented on Jul 27, 2018

bterlson commented on Jul 27, 2018

bterlson commented on Jul 27, 2018

anurbol commented on Jul 28, 2018

rsolomon commented on Aug 3, 2018

pleerock commented on Dec 21, 2019

dragomirtitian commented on Dec 22, 2019

pleerock commented on Dec 22, 2019

dianjuar commented on Mar 16, 2020

dragomirtitian commented on Mar 16, 2020

bhishp commented on Jun 2, 2020

aztack commented on Nov 5, 2020

Thyregod commented on Feb 24, 2021

bhishp commented on Feb 24, 2021

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions