Feature Request: Instantiate Generic Functions within Conditional Types

[sinclairzx81]

🔍 Search Terms

Instantiation Expressions, Conditional Types

✅ Viability Checklist

• 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 isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

I am looking for a way to be able to instantiate a generic function / return type via conditional type.

// some method

declare function method<T>(value: T): T

// ... this is possible

type R0 = ReturnType<typeof method<number>> 

// ... but this isn't 

type Infer<Func extends <T>(value: T) => unknown, U> = ReturnType<Func<U>>

type R1 = Infer<typeof method, number>

Related Issue: #22617

📃 Motivating Example

I have written a small type-level parser for one of the libraries I manage. I have support for type parameterization.

Parameterized Type

const T = Syntax('number') 

const Vector = Syntax({ T }, `{ x: T, y: T, z: T }`)  // const T: TObject<{
                                                      //   x: TNumber,
                                                      //   y: TNumber,
                                                      //   z: TNumber
                                                      // }>

... but would also like to support generic functions as parameters (and resolve exterior types via function call / instantiation expression)

const Vector = <T extends TSchema>(T: T) => Type.Object({ x: T, y: T, z: T })

const T = Syntax({ Vector }, `Vector<number>`)        // const T: TObject<{
                                                      //    x: TNumber,
                                                      //    y: TNumber,
                                                      //    z: TNumber
                                                      // }>
                                      

When implementing the second case, I noticed it's not actually possible to instantiate the Vector signature within the context of a conditional type expression (i.e. the parser). In this case, I have a parsed TNumber type ready to supply the generic Vector function, but no way to instantiate it.

Essentially I would need the following but in a conditional type (Reference)

const Vector = <T extends TSchema>(T: T) => Type.Object({ x: T, y: T, z: T })

// ... internal to the parser

type ParsedNumber = TNumber 

type Instanced = ReturnType<typeof Vector<ParsedNumber>> // need this via conditional type

💻 Use Cases

1. What do you want to use this for?

Implement generic types in a type level syntax parser.

2. What shortcomings exist with current approaches?

Cannot instantiate generic signatures within a conditional type.

3. What workarounds are you using in the meantime?

I'm not sure there are workarounds.

[jcalz]

#40542, #47607

I think I remember that extending instantiation expressions to the type level would give an ambiguous meaning to a type of the form F<T>. Like, what if you have type F<T=X> = <U>(u: U, t:T) => [T, U] or something? I’m sure that can be addressed but it’s messy.

#47607 (comment)

[sinclairzx81]

@jcalz Hi, thanks for the reference links

Hmmm, it does seem this feature has been lingering for several years now. Reading up, it looks like the main challenges were a combination of design limitations (as it was in 2018) and a syntax differentiation issue, finding a way to make an appropriate distinction between "type instantiation" and "instantiation expression" within the context of conditional types.

It would be great to get an update though.

[RyanCavanaugh]

See also #40179

[sinclairzx81]

Update: I've since found an alternative solution that solves for the motivating example

Solution supported for TS 4.8.4 and above (Reference).

// Generic Arguments
const T0 = Type.Argument(0)
const T1 = Type.Argument(1)
const T2 = Type.Argument(2)

// Generic Type with Parameters
const Vector = Syntax({ T0, T1, T2 },  `{
  x: T0,
  y: T1,
  z: T2
}`)

// Syntax Instantiated Generic Types (Solution Here)
const BasisVectors = Syntax({ Vector }, `{
  readonly type: 'BasisVectors'
  x: Vector<1, 0, 0>,
  y: Vector<0, 1, 0>,
  z: Vector<0, 0, 1>,
}`)

type BasisVectors = Static<typeof BasisVectors>

// type BasisVectors = {
//   readonly type: "BasisVectors";
//   x: { x: 1; y: 0; z: 0; };
//   y: { x: 0; y: 1; z: 0; };
//   z: { x: 0; y: 0; z: 1; };
// }

---

Would still be keen for the requested feature. For future reference, here is an updated (and simpler) case where the ConditionalReturnType type cannot be reasonably implemented (TS 5.8.0)

declare function method<T>(value: T): T

// ...

type A = ReturnType<typeof method<number>>               // type A: number

type ConditionalReturnType<F, T> = { ... }               // ... this type cannot be implemented

type B = ConditionalReturnType<typeof method, number>    // type B: ???