What can TypeScript do with high-level type functions?

Question

What can TypeScript do with high-level type functions?

Take a look at the following pseudo-code attempting to define a higher-order type function with a function-typed parameter M<?>:

type HigherOrderTypeFn<T, M<?>> = T extends (...)
  ? M<T>
  : never;

The syntax M<?> is not valid TypeScript, but defining the type as HigherOrderTypeFn<T, M> triggers an error

Type 'M' is not generic. ts(2315)

on the second line.

Does this mean that such a type is currently impossible to represent in TS?

typescript generics nested-generics open-generics

Answer 1

Answer №1

It is true that TypeScript currently does not support higher kinded types. A feature request on GitHub, microsoft/TypeScript#1213, discusses this issue under the title "Allow classes to be parametric in other parametric classes".

While there are suggestions on how to simulate higher kinded types within the language, it may not be suitable for production code. If you have a specific structure in mind, feel free to share and seek advice.

If you believe in pushing for this feature, consider showing support on the GitHub issue by giving it a thumbs up or explaining your use case to help make it more compelling. Every little bit helps!

Answer 2

It is true that TypeScript currently does not support higher kinded types. A feature request on GitHub, microsoft/TypeScript#1213, discusses this issue under the title "Allow classes to be parametric in other parametric classes".

While there are suggestions on how to simulate higher kinded types within the language, it may not be suitable for production code. If you have a specific structure in mind, feel free to share and seek advice.

If you believe in pushing for this feature, consider showing support on the GitHub issue by giving it a thumbs up or explaining your use case to help make it more compelling. Every little bit helps!

Answer 3

Answer №2

If you're looking for a workaround, here's a simple suggestion that uses placeholders as a basis (refer to this comment in the discussion highlighted by jcalz):

type Placeholder = {'aUniqueKey': unknown};
type Replace<T, X, Y> = {
  [k in keyof T]: T[k] extends X ? Y : T[k];
};

Therefore, your function would appear like this:

type HigherOrderTypeFn<T, M> = T extends (...) ? Replace<M, Placeholder, T> : never;

and can be invoked, for instance, in this way:

type M<U> = U[];
type X = HigherOrderTypeFn<number, M<Placeholder>> // results in number[] (if ... is number)

Answer 4

If you're looking for a workaround, here's a simple suggestion that uses placeholders as a basis (refer to this comment in the discussion highlighted by jcalz):

type Placeholder = {'aUniqueKey': unknown};
type Replace<T, X, Y> = {
  [k in keyof T]: T[k] extends X ? Y : T[k];
};

Therefore, your function would appear like this:

type HigherOrderTypeFn<T, M> = T extends (...) ? Replace<M, Placeholder, T> : never;

and can be invoked, for instance, in this way:

type M<U> = U[];
type X = HigherOrderTypeFn<number, M<Placeholder>> // results in number[] (if ... is number)

Answer 5

Answer №3

For those who stumble upon this information, there is a great example circulating on the TypeScript discord community:

export interface Hkt<I = unknown, O = unknown> {
  [Hkt.isHkt]: never,
  [Hkt.input]: I,
  [Hkt.output]: O,
}

export declare namespace Hkt {
  const isHkt: unique symbol
  const input: unique symbol
  const output: unique symbol

  type Input<T extends Hkt<any, any>> =
    T[typeof Hkt.input]

  type Output<T extends Hkt<any, any>, I extends Input<T>> =
    (T & { [input]: I })[typeof output]

  interface Compose<O, A extends Hkt<any, O>, B extends Hkt<any, Input<A>>> extends Hkt<Input<B>, O>{
    [output]: Output<A, Output<B, Input<this>>>,
  }

  interface Constant<T, I = unknown> extends Hkt<I, T> {}
}

There are various use cases for this example code. One key component is defining a SetFactory, allowing you to specify the desired set type when creating a factory, such as typeof FooSet or typeof BarSet. The constructor type takes any T and returns a FooSet<T>, similar to a higher kinded type. Methods like createNumberSet can then be used to create new sets of a specific type, with parameters set accordingly.

interface FooSetHkt extends Hkt<unknown, FooSet<any>> {
    [Hkt.output]: FooSet<Hkt.Input<this>>
}
class FooSet<T> extends Set<T> {
    foo() {} 
    static hkt: FooSetHkt;
}

interface BarSetHkt extends Hkt<unknown, BarSet<any>> {
    [Hkt.output]: BarSet<Hkt.Input<this>>;
}
class BarSet<T> extends Set<T> { 
    bar() {} 
    static hkt: BarSetHkt;
}

class SetFactory<Cons extends {
    new <T>(): Hkt.Output<Cons["hkt"], T>;
    hkt: Hkt<unknown, Set<any>>;
}> {
    constructor(private Ctr: Cons) {}
    createNumberSet() { return new this.Ctr<number>(); }
    createStringSet() { return new this.Ctr<string>(); }
}

// SetFactory<typeof FooSet>
const fooFactory = new SetFactory(FooSet);
// SetFactory<typeof BarSet>
const barFactory = new SetFactory(BarSet);

// FooSet<number>
fooFactory.createNumberSet();
// FooSet<string>
fooFactory.createStringSet();

// BarSet<number>
barFactory.createNumberSet();
// BarSet<string>
barFactory.createStringSet();

To better understand how this works, let's consider the interaction between FooSet and number:

The crucial point is the type
```
Hkt.Output<Const["hkt"], T>
```
. In our case, this translates into
```
Hkt.Output<(typeof FooSet)["hkt"], number>
```
, which ultimately results in FooSet<number>.
We first resolve (typeof FooSet)["hkt"] to FooSetHkt, storing the creation details in the static hkt property of FooSet. This step should be repeated for each supported class.
Next, we have
```
Hkt.Output<FooSetHkt, number>
```
. By resolving the Hkt.Output alias, we get
```
(FooSetHkt & { [Hkt.input]: number })[typeof Hkt.output]
```
, utilizing unique symbols to ensure uniqueness.
Now, accessing the Hkt.output property of FooSetHkt, we find the instructions to construct a concrete type with the argument. For FooSetHkt, the output is defined as
```
FooSet<Hkt.Input<this>>
```
.
Finally, through Hkt.Input<this>, we access the Hkt.input property of FooSetHkt. By tweaking it to include number, we reach number as the result, leading to FooSet<number>.

In essence, the previous discussion surrounding Hkt.Output applies to the given example but with reversed type parameters:

interface List<T> {}
interface ListHkt extends Hkt<unknown, List<any>> {
    [Hkt.output]: List<Hkt.Input<this>>
}
type HigherOrderTypeFn<T, M extends Hkt> = Hkt.Output<M, T>;
// Outputs List<number>
type X = HigherOrderTypeFn<number, ListHkt>;

Answer 6

For those who stumble upon this information, there is a great example circulating on the TypeScript discord community:

export interface Hkt<I = unknown, O = unknown> {
  [Hkt.isHkt]: never,
  [Hkt.input]: I,
  [Hkt.output]: O,
}

export declare namespace Hkt {
  const isHkt: unique symbol
  const input: unique symbol
  const output: unique symbol

  type Input<T extends Hkt<any, any>> =
    T[typeof Hkt.input]

  type Output<T extends Hkt<any, any>, I extends Input<T>> =
    (T & { [input]: I })[typeof output]

  interface Compose<O, A extends Hkt<any, O>, B extends Hkt<any, Input<A>>> extends Hkt<Input<B>, O>{
    [output]: Output<A, Output<B, Input<this>>>,
  }

  interface Constant<T, I = unknown> extends Hkt<I, T> {}
}

There are various use cases for this example code. One key component is defining a SetFactory, allowing you to specify the desired set type when creating a factory, such as typeof FooSet or typeof BarSet. The constructor type takes any T and returns a FooSet<T>, similar to a higher kinded type. Methods like createNumberSet can then be used to create new sets of a specific type, with parameters set accordingly.

interface FooSetHkt extends Hkt<unknown, FooSet<any>> {
    [Hkt.output]: FooSet<Hkt.Input<this>>
}
class FooSet<T> extends Set<T> {
    foo() {} 
    static hkt: FooSetHkt;
}

interface BarSetHkt extends Hkt<unknown, BarSet<any>> {
    [Hkt.output]: BarSet<Hkt.Input<this>>;
}
class BarSet<T> extends Set<T> { 
    bar() {} 
    static hkt: BarSetHkt;
}

class SetFactory<Cons extends {
    new <T>(): Hkt.Output<Cons["hkt"], T>;
    hkt: Hkt<unknown, Set<any>>;
}> {
    constructor(private Ctr: Cons) {}
    createNumberSet() { return new this.Ctr<number>(); }
    createStringSet() { return new this.Ctr<string>(); }
}

// SetFactory<typeof FooSet>
const fooFactory = new SetFactory(FooSet);
// SetFactory<typeof BarSet>
const barFactory = new SetFactory(BarSet);

// FooSet<number>
fooFactory.createNumberSet();
// FooSet<string>
fooFactory.createStringSet();

// BarSet<number>
barFactory.createNumberSet();
// BarSet<string>
barFactory.createStringSet();

To better understand how this works, let's consider the interaction between FooSet and number:

The crucial point is the type
```
Hkt.Output<Const["hkt"], T>
```
. In our case, this translates into
```
Hkt.Output<(typeof FooSet)["hkt"], number>
```
, which ultimately results in FooSet<number>.
We first resolve (typeof FooSet)["hkt"] to FooSetHkt, storing the creation details in the static hkt property of FooSet. This step should be repeated for each supported class.
Next, we have
```
Hkt.Output<FooSetHkt, number>
```
. By resolving the Hkt.Output alias, we get
```
(FooSetHkt & { [Hkt.input]: number })[typeof Hkt.output]
```
, utilizing unique symbols to ensure uniqueness.
Now, accessing the Hkt.output property of FooSetHkt, we find the instructions to construct a concrete type with the argument. For FooSetHkt, the output is defined as
```
FooSet<Hkt.Input<this>>
```
.
Finally, through Hkt.Input<this>, we access the Hkt.input property of FooSetHkt. By tweaking it to include number, we reach number as the result, leading to FooSet<number>.

In essence, the previous discussion surrounding Hkt.Output applies to the given example but with reversed type parameters:

interface List<T> {}
interface ListHkt extends Hkt<unknown, List<any>> {
    [Hkt.output]: List<Hkt.Input<this>>
}
type HigherOrderTypeFn<T, M extends Hkt> = Hkt.Output<M, T>;
// Outputs List<number>
type X = HigherOrderTypeFn<number, ListHkt>;

Answer 7

Answer №4

There is an innovative use of Higher Kinded Types (HKTs) by taking advantage of module augmentation in fp-ts library.

To navigate around the limitations of Higher Kinded Types, the author has provided a solution through this documentation:

export interface HKT<URI, A> {
  readonly _URI: URI;
  readonly _A: A;
}

This can be implemented as follows:

export interface Foldable<F> {
  readonly URI: F;
  reduce: <A, B>(fa: HKT<F, A>, b: B, f: (b: B, a: A) => B) => B;
}

For further clarification on this topic, consider visiting this question: Higher Kinded Type in TypeScript from fp-ts and URI

Exploring this discussion may illuminate some aspects for you.

Cheers!

Answer 8

There is an innovative use of Higher Kinded Types (HKTs) by taking advantage of module augmentation in fp-ts library.

To navigate around the limitations of Higher Kinded Types, the author has provided a solution through this documentation:

export interface HKT<URI, A> {
  readonly _URI: URI;
  readonly _A: A;
}

This can be implemented as follows:

export interface Foldable<F> {
  readonly URI: F;
  reduce: <A, B>(fa: HKT<F, A>, b: B, f: (b: B, a: A) => B) => B;
}

For further clarification on this topic, consider visiting this question: Higher Kinded Type in TypeScript from fp-ts and URI

Exploring this discussion may illuminate some aspects for you.

Cheers!

What can TypeScript do with high-level type functions?

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

`Error importing react-markdown in Next.js 11.1 with TypeScript``

How can one access DOM elements (getting and setting values) that are nested within an *ngFor loop?

A comprehensive guide on displaying data in Angular using an API

Enhance your workflow with Visual Studio Code by incorporating multiple commands

Jest test encounters an error due to an unexpected token, looking for a semicolon

increase the selected date in an Angular datepicker by 10 days

When evaluating objects or arrays of objects to determine modifications

Tips for effectively typing a collection of React wrappers in TypeScript

Currently focused on developing vertical sliders that can be manipulated by dragging them up or down independently

TS - deduce the specific type of a key value without receiving a union type

Clicking on an element- how can I find the nearest element?

Is it possible to utilize an XML format for translation files instead of JSON in React Native?

Exploring the Depths of JSON Arrays within Typescript

Identifying unique properties with specific keys in a Typescript object

Developing an Angular 2 Cordova plugin

What is the best way to set a checkbox to null instead of false using Angular?

Executing a Prisma query with a selection

Creating an auth guard in Angular Fire v7 using the latest API (not backwards compatible)

Is it necessary to create a unit test for a basic operation involving RxJS?

Create an array of arrays within a loop using TypeScript