Invoke callable types on type level

[aspirisen]

Suggestion

🔍 Search Terms

Call function type
Invoke function type
Function return type
Generic function return type
Simplify extends conditions

✅ 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

Allow callable function types invoking on type level. The logic behind it is the same as we have for usual function calling

interface One {
   (): string
}

type Result = One() // Result is string

If function type has arguments we must pass them as well, but use types as argument

interface Data {
   name: string
}

type One = (value: number, data: Data) => boolean
type Result = One(number, Data) // Result is boolean

The same logic with generics

interface Data {
   name: string
}

type One = <T>(value: number, data: T) => T

type Result = One<Data>(number, Data) // Result is Data
type Result = One(number, Data) // Result is Data because of type inference

type Result2 = One(number, boolean) // Result is boolean

However, there is a problem when the type itself has a generic

type One<V> = <T>(value: V, data: T) => T

// Implicitly merge them in one row?
type Result = One<number, Data>(number, Data)

// Think about some other syntax ?
type Result = One<number><Data>(number, Data)

// Surround by brackets?
type Result = (One<number>)<Data>(number, Data)

📃 Motivating Example

Typescript has callable types, i.e.

interface One{
   (value: string): string
}


type Two = () => string

and when we need to to get the return type we can use ReturnType type to inference the type

interface One {
   (value: string): string
}


type Result = ReturnType<One>

But there are problems when you have overloading

interface One {
   (value: string): string
   (value: number): number
}


type Result = ReturnType<One>

The things becomes even more complex if you have generics

interface One {
   <T>(value: T): T
}


type Result = ReturnType<One>

The Result will be just unknown

💻 Use Cases

We will be able to create a type of what function is returning:

declare function createData(condition: 'a'): { a: number; b: number }
declare function createData(condition: 'b'): { c: number; d: number }

type CreateData = typeof createData
type DataA = CreateData('a') // DataA is { a: number; b: number }
type DataB = CreateData('b') // DataB is { c: number; d: number }

We will be able to deal with generic functions

declare function factory<T>(data: T): { getValue(): T; setValue(value: T): void }

type Factory = typeof factory
type MyFactory1 = Factory({ name: string }) // MyFactory1 is { getValue(): { name: string }; setValue(value: { name: string }): void }
type MyFactory2 = Factory({ email: string }) // MyFactory2 is { getValue(): { email: string }; setValue(value: { email: string }): void }

We can simplify extends conditions. For example we have a type with a lot of ? conditions. If there are a lot of conditions it is becomes harder to read them.

interface Data {
   name: string
}


type SomeCondition<T> = T extends number ? 'number' : T extends Data ? 'data' : T extends string ? 'string' : unknown

and since functions can have overloading we can use it as switch case

interface Data {
   name: string
}

interface SomeCondition {
    (value: number): 'number'
    (value: Data): 'data'
    (value: string): 'string'

    // Works as default case
    (...value: any[]): unknown
}

// or

interface SomeCondition {
    <T extends number>(value: T): 'number'
    <T extends Data>(value: T): 'data'
    <T extends string>(value: T): 'string'

    // Works as default case
    (...value: any[]): unknown
}

type A = SomeCondition(number) // A is 'number'
type B = SomeCondition(Data) // B is 'data'
type C = SomeCondition(string) // C is 'string'
type D = SomeCondition(true) // D is unknown

So it works exactly the same as we would just normally call functions

declare const data: Data
declare const logic: SomeCondition

const a = logic(1) // a is 'number'
const b = logic(data) // b is 'data'
const c = logic('foo') // c is 'string'
const d = logic(true) // d is unknown

[fatcerberus]

Looks like a duplicate of #40179

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.