FnChain

[loynoir]

Suggestion

🔍 Search Terms

• strict Parameters<T>
• associated ReturnType<T>
• curry function

✅ Viability 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. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

Given

type MP2 = {
  a1: "a2";
  b1: "b2";
};
type MP3 = {
  a1: "a3";
  b1: "b3";
};
type MR = {
  a1: "ar";
  b1: "br";
};
function foo<K extends keyof MP2>(p1: K, p2: MP2[K], p3: MP3[K]): MR[K] {
  return { p1, p2, p3 } as any;
}

type FooFnChain = FnChain<typeof foo>;

type FooFnChainExpected =
  | { params: ["a1", "a2", "a3"]; result: "ar" }
  | { params: ["b1", "b2", "b3"]; result: "br" };

📃 Motivating Example

// [p1: keyof MP2, p2: "a2" | "b2", p3: "a3" | "b3"]
type FooParameters = Parameters<typeof foo>;
// "ar" | "br"
type FooReturn = ReturnType<typeof foo>;

// @ts-expect-error
foo('a1','b2','b3')

// no error
const a:FooParameters = ['a1', 'b2', 'b3']
void a

// no error
curry(foo)('a1')('b2')('b3')

// "ar" | "br"
const r = curry(foo)('a1')('a2')('a3')

💻 Use Cases

// @ts-expect-error
foo('a1','b2','b3')

// @ts-expect-error
const a:FnChain<typeof foo>['params'] = ['a1', 'b2', 'b3']
void a

// @ts-expect-error
curry(foo)('a1')('b2')('b3')

// "ar"
const r = curry(foo)('a1')('a2')('a3')

[RyanCavanaugh]

This is already possible with function instantiation expressions:

type Distribute<K extends keyof MP2> = { params: Parameters<typeof foo<K>>, result: ReturnType<typeof foo<K>> };
type FnChain<K extends keyof MP2> = K extends unknown ? Distribute<K> : never;
type FooFnChain = FnChain<"a1" | "b1">;

[nopeless]

type anyFn = (...args: any) => any;
type Curry<F extends anyFn> = F extends () => any ? ReturnType<F> : F extends (arg: infer I, ...args: infer R) => any ? (arg: I) => (...args: R) => ReturnType<F> : never;

?

[nopeless]

I belive this issue is related to the other library not TypeScript itself

quick demo

[loynoir]

@nopeless

type MP2 = {
  a1: "a2";
  b1: "b2";
};
type MP3 = {
  a1: "a3";
  b1: "b3";
};
type MR = {
  a1: "ar";
  b1: "br";
};
function foo<K extends keyof MP2>(p1: K, p2: MP2[K], p3: MP3[K]): MR[K] {
  return { p1, p2, p3 } as any;
}


type anyFn = (...args: any) => any;

type Curry<F extends anyFn> = F extends () => any ? ReturnType<F> : F extends (arg: infer I, ...args: infer R) => any ? (arg: I) => (...args: R) => ReturnType<F> : never;

function curry<F extends anyFn>(fn: F): Curry<F> {
	return null as any;
}

// Actual: no error
// Expected: error
curry(foo)('a1')('b2', 'b3')

[nopeless]

@loynoir

// Actual: no error
// Expected: error
const fooc = curry<typeof foo<'a1'>>(foo)('a1')('b2', 'b3')
//    ^?

You need the explicit function type

However, I'm sure that making more types to allow curry(foo)('a1') to be inferred disrupts the purpose of currying

[typescript-bot]

This issue has been marked as 'Question' and has seen no recent activity. It has been automatically closed for house-keeping purposes. If you're still waiting on a response, questions are usually better suited to stackoverflow or the TypeScript Discord community.