Function Type Alias with No Particular Name

Question

Function Type Alias with No Particular Name

Have you ever wondered why in TypeScript type alias doesn't work with a generic function? Take for example the scenario where TS fails to define type Identical as generic.

type Identical = <T>(v: T) => T;

const identical: Identical<string> = (v) => v

It is interesting to note that the correct method is:

type Identical<T> = (v: T) => T;

But what exactly is causing the first example to not work and what is the type of T?

typescript

Answer 1

Answer №1

For the purpose of this explanation, I will define "specific" as the opposite of "generic". While some may use "concrete" to convey this idea, there is a risk of confusion with the term "abstract", which is unrelated to abstract classes.

Aside from generic functions, TypeScript only supports generic types, not generic values. To declare a generic type, the type parameter is placed in angle brackets after the type name:

type GenericType<T> = {x: T};

You can define a generic type like Foo<T>, but any actual value of that type must be specific and include a specified specific type for T:

declare const badValue1: GenericType; // error, needs 1 type argument
declare const badValue2: GenericType<T>; // error, 'T' not found
declare const goodValue: GenericType<string>; // valid

It's important to note that GenericType<string> now represents a specific type equivalent to {x: string}. Specifying generic parameters results in a specific type output.

Unlike generic types, values of generic functions are themselves generic. They encompass a variety of specific function types. In a generic function type, the type parameter comes before the function's parameter list within angle brackets:

type GenericFunction = <T>(x: T, y: T) => void;

The generic function's type itself is not generic; no type parameter appears in the GenericFunction declaration above. Therefore, you only specify the type parameter when actually calling the function:

declare const badFunc: GenericFunction<string>; // error, not a generic function
declare const goodFunc: GenericFunction; // valid
const ret = goodFunc<string>("okay", "fine"); // type parameter set as string
const ret2 = goodFunc("okay", "fine"); // type parameter inferred as string

Simply put, the distinction between these two:

 type IdGenericType<T> = (x: T) => T;
 type IdGenericFunc = <T>(x: T) => T;

lies in the fact that the first is a generic type that resolves to a specific function upon specification, while the second is a specific type representing a generic function. Although related, these types are not interchangeable. You can assign a value of type IdGenericFunc to any variable of type IdGenericType<XXX>, using any specific type XXX:

let id: IdGenericFunc = x => x;
let idString: IdGenericType<string> = id; // valid

But the reverse does not hold true:

const otherId: IdGenericFunc = idString; // error! Incompatible types

This discrepancy makes sense since an IdGenericType<string> is known to accept and return a string only:

idString = x => x + "!"; // valid

Therefore, assuming an IdGenericType<string> is identical to a valid IdGenericFunc would be inaccurate. The relationship between IdGenericType<T> and IdGenericFunc can be likened to intersecting all instances of IdGenericType<T> across all possible T values:

// type IdGenericFunc = forall T. IdGenericType<T>; // Syntax invalid

Although TypeScript lacks a direct way to represent this concept (borrowed syntax from Haskell), the fundamental distinctions remain.

To delve deeper into generic values in TypeScript, refer to the GitHub issue at microsoft/TypeScript#17574.

Code Link Here

Answer 2

For the purpose of this explanation, I will define "specific" as the opposite of "generic". While some may use "concrete" to convey this idea, there is a risk of confusion with the term "abstract", which is unrelated to abstract classes.

Aside from generic functions, TypeScript only supports generic types, not generic values. To declare a generic type, the type parameter is placed in angle brackets after the type name:

type GenericType<T> = {x: T};

You can define a generic type like Foo<T>, but any actual value of that type must be specific and include a specified specific type for T:

declare const badValue1: GenericType; // error, needs 1 type argument
declare const badValue2: GenericType<T>; // error, 'T' not found
declare const goodValue: GenericType<string>; // valid

It's important to note that GenericType<string> now represents a specific type equivalent to {x: string}. Specifying generic parameters results in a specific type output.

Unlike generic types, values of generic functions are themselves generic. They encompass a variety of specific function types. In a generic function type, the type parameter comes before the function's parameter list within angle brackets:

type GenericFunction = <T>(x: T, y: T) => void;

The generic function's type itself is not generic; no type parameter appears in the GenericFunction declaration above. Therefore, you only specify the type parameter when actually calling the function:

declare const badFunc: GenericFunction<string>; // error, not a generic function
declare const goodFunc: GenericFunction; // valid
const ret = goodFunc<string>("okay", "fine"); // type parameter set as string
const ret2 = goodFunc("okay", "fine"); // type parameter inferred as string

Simply put, the distinction between these two:

 type IdGenericType<T> = (x: T) => T;
 type IdGenericFunc = <T>(x: T) => T;

lies in the fact that the first is a generic type that resolves to a specific function upon specification, while the second is a specific type representing a generic function. Although related, these types are not interchangeable. You can assign a value of type IdGenericFunc to any variable of type IdGenericType<XXX>, using any specific type XXX:

let id: IdGenericFunc = x => x;
let idString: IdGenericType<string> = id; // valid

But the reverse does not hold true:

const otherId: IdGenericFunc = idString; // error! Incompatible types

This discrepancy makes sense since an IdGenericType<string> is known to accept and return a string only:

idString = x => x + "!"; // valid

Therefore, assuming an IdGenericType<string> is identical to a valid IdGenericFunc would be inaccurate. The relationship between IdGenericType<T> and IdGenericFunc can be likened to intersecting all instances of IdGenericType<T> across all possible T values:

// type IdGenericFunc = forall T. IdGenericType<T>; // Syntax invalid

Although TypeScript lacks a direct way to represent this concept (borrowed syntax from Haskell), the fundamental distinctions remain.

To delve deeper into generic values in TypeScript, refer to the GitHub issue at microsoft/TypeScript#17574.

Code Link Here

Function Type Alias with No Particular Name

Answer №1

Similar questions

Tips for testing nested HTTP calls in unit tests

The field value exceeds the limit of characters allowed (3184658) and should be submitted using form

TypeORM Error: Trying to access the 'id' property of an undefined object

Using *ngFor to dynamically update the DOM when an array is modified via ngrx

Click the button to collapse the dropdown menu - Angular Material

Creating Custom Type Guards for Literal Types in Typescript: Is It Possible?

Issue: IntelliSense in VS Code is not functioning properly due to comment formatting conflicts with @types/node

Pass data from the HTML component to the TypeScript component

Using TypeScript with Visual Studio Code to reference a renamed file

I'm having trouble setting a value for an object with a generic type

Using Typescript to create an index signature for easily accessing child objects through a proxy

The TypeScript error message states that a value of 'undefined' cannot be assigned to a type that expects either a boolean, Connection

Angular module with customizable configurations

Obtain the selected type from a tuple after filtering

Using TypeScript to define a generic type for the key in a React select component

The prototype's function doesn't pause for anything, carrying out its duty in a continuous cycle

Unusual class title following npm packaging

Experimenting with a file system library function using Jest and Typescript alongside a placeholder function

Can a file be transferred from the private path to the document directory?

Listening to events on the iterative variable of NgFor directive in Angular 2