// your answers

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

Solution by PAVANT009 #37588

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

Solution by tomo-local #37584

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

---

• <T extends (...args: any[]) => any>

  • A single generic parameter T.

  • T must be a function type.

  • The part (...args: any[]) => any means:

    • It’s a function that can take any number of arguments (of any type).
    • It returns any type of value.

• T extends (...args: infer A) => any ? A : never

  • A conditional type that checks whether T matches the shape of a function.

  • The keyword infer tells TypeScript:

    “If you can figure out the type of the function’s parameters, call that type A.”

  • If the match succeeds → return A (the tuple of parameter types).

  • If it fails → return never.

---

In plain words

MyParameters<T> constructs a new type by:

1. Taking a function type T.
2. Extracting (or inferring) its parameter types as a tuple.
3. Returning that tuple — or never if T isn’t a function.

---

✅ Example

const greet = (name: string, age: number): void => {}
type Params = MyParameters<typeof greet>
// Step by step:
// T = (name: string, age: number) => void
// infer A = [name: string, age: number]
// Result = [string, number]

✅ Final result: Params is [string, number]. 🎯

Solution by 3aluw #37562

type MyParameters<T extends (...args: any[]) => any> = T extends (...params: infer S) => any ? S : [];

Solution by BangTtagGum #37306

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

Solution by djdidi #37140

• Here we check if T is a function
• infer P is the type of the parameter tuple passed
• if T is any type, then the type of the parameter is passed, else never

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

Solution by Anonymous961 #37095

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

Solution by 359Steve #37023

// your answers
type MyParameters<T extends (...args: any[]) => any> = T extends (...args: infer T) => any ? T : never;

Solution by AlexBraunMagic #36910

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

Solution by shaishab316 #36850

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

Solution by Abdullah-Elsayed01 #36803

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

/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'

function foo(arg1: string, arg2: number): void {}
function bar(arg1: boolean, arg2: { a: 'A' }): void {}
function baz(): void {}

type cases = [
  Expect<Equal<MyParameters<typeof foo>, [string, number]>>,
  Expect<Equal<MyParameters<typeof bar>, [boolean, { a: 'A' }]>>,
  Expect<Equal<MyParameters<typeof baz>, []>>,
]

Solution by AnastasiaSv #36770

type MyParameters<T extends (...args: any[]) => any> = T extends (...args: infer A) => any ? A : []

Solution by tungulin #36721

// 여기 풀이를 입력하세요
type MyParameters<T extends (...args: any[]) => any> = T extends (...args: infer U) => any ? U : never

Solution by seungdeok #36684

type MyParameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never

Solution by ChemieAi #36558

type MyParameters<T> = T extends (...args: infer U) => unknown ? U : never

Solution by Divcutu #36501

type MyParameters<T extends (...args: any[]) => any> = T extends (...args:infer P) => any ? P : []

Solution by tac-tac-go #36488

// 你的答案
type MyParameters<T extends (...args: any[]) => any> = T extends (
  ...args: infer Params
) => any
  ? Params
  : never;

Solution by aeasx #36466

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

Solution by HelloWook #36425

// your answers

Solution by alirezaprime #36407

// your answers
type MyParameters<T extends (...args: any[]) => any> = 
T extends ((...args: infer R extends readonly any[]) => any)? R : never; 

Solution by justBadProgrammer #36394

type MyParameters<T extends (...args: any[]) => any> = T extends (...args: infer U) => any ? U : any

Solution by jungwoo3490 #36323

解释： 遍历数组，每次都把数组第一项传入Count，如果Count === Z(每组个数)，则将Count传入Res(结果)，并清空Count

type Chunk<A extends any[], Z extends number, Count extends any[] = [], Res extends any[] = []> = A extends [infer S,  ...infer Rest]
  ?  Z extends [...Count, S]['length'] 
    ? Chunk<[...Rest], Z, [], [...Res, [...Count, S]]>
    : Chunk<[...Rest], Z, [...Count, S], Res>
  : Count['length'] extends 0 
    ? Res
    : [...Res, [...Count]]

Solution by LioHng #36320

type MyParameters<T extends (...args: any) => any> =
  T extends (...args: infer P) => any ? P : never

Solution by 1Alex4949031 #36318

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

Solution by asylbekduldiev #36298

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

Solution by EvilEl #36249

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

Solution by Maxim-Do #36229

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

Solution by AleksandrShcherbackov #36148

type MyParameters<T extends (...args: any[]) => void> = T extends (...args: infer R) => void ? R : never

Solution by dekguh #36077

// 你的答案
type MyParameters<T> = T extends (...args: infer P) => any ? P : any;

Solution by reonce #36052

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

Solution by karazyabko #36034