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

Unlock the key to connecting the output of one observable to another in rxjs

Webpack is throwing an error due to the Vue component type being labeled as "any"

Why is my Typescript event preventDefault function ineffective?

Determining the type inference in Typescript based on column data objects

Ways to prevent encountering the "ERROR: Spec method lacks expectations" message despite achieving success

The Ionic search bar will only initiate a search once the keyboard is no longer in view

Converting text data into JSON format using JavaScript

Is it possible to nullify an object and utilize nullish coalescing for handling potentially undefined constants?

Implementing theme in Monaco editor without initializing an instance

The Nest.js Inject decorator is not compatible with property-based injection

What steps are involved in constructing Jodit from scratch?

Karma Jasmin is puzzled as to why her tests are failing intermittently, despite the absence of any actual test cases

There is a potential for the object to be 'undefined' when calling the getItem method on the window's local storage

What is preventing type-graphql from automatically determining the string type of a class property?

`When attempting to use Typescript with Electron, the error 'exports is not defined

What is the best way to implement lazy loading for child components in React's Next.js?

The Angular 2 view will remain unchanged until the user interacts with a different input box

Does the routing in Angular 2 get disrupted by parameter breaks in sub-modules?

Is there a way to modify the style within a TS-File?

Is it possible to import a class from a different project or module in TypeScript?