Discussing recursive types A <--> B with generics in TypeScript

Question

Discussing recursive types A <--> B with generics in TypeScript

I'm currently working with the following TypeScript code:

type DormNodePredicate = DormEdge | (() => DormNode<DormNodePredicateRecord>);
interface DormNodePredicateRecord {
  [key: string]: DormNodePredicate;
}

export class DormNode<DNPR extends DormNodePredicateRecord> {
  constructor(public preds: DNPR) {}
}

enum PredicateType {
  STRING = "string"
}

export class DormEdge<AsArray extends boolean = false> {
  constructor(private predType: PredicateType, asArray: AsArray = false as AsArray) {}
}

const Audit = new DormNode({
  user: () => User
}) 

const User = new DormNode({
  name: new DormEdge(PredicateType.STRING),
  audits: () => Audit
});

The issue I'm facing is that both Audit and User are being inferred as type any. To reach a deep level of recursion like

Audit.preds.user().preds.audits()...

, I need to reference Audit from User. Although this example is simple, my actual use case involves much more complexity. How can I resolve this?

In relation to this part of the code:

export class DormEdge<AsArray extends boolean = false> {...}

Removing the = false from the generics allows me to achieve my original intention. However, I'm unsure about the underlying mechanics at play here. Any assistance in identifying the problem would be greatly appreciated. For further context, I am utilizing

<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="3d49444d584e5e4f544d497d3c502b59584441">[email protected]</a>

. Thank you!

typescript typescript-generics recursive-type

Answer 1

Answer №1

The algorithm used by TypeScript for type inference operates on a heuristic basis, meaning that if it encounters a loop while trying to deduce a type, it will default to an implicit any. This heuristic approach generally handles common circular dependencies found in real-world code effectively. However, there are scenarios where it falls short, requiring a major revamp of the inference process to incorporate full unification, as discussed in microsoft/TypeScript#30134. Yet, this overhaul is unlikely due to the extensive effort it would entail and the potential decline in IDE performance for common use cases.

In situations where the compiler struggles to analyze code due to circular references, humans often find it straightforward to resolve these issues manually. Despite users reporting such circularities as bugs on TypeScript's GitHub repository, they are typically categorized as design limitations rather than defects. Comments from developers often emphasize that the current implementation is a balance between accuracy and resource allocation. Refer to examples like microsoft/TypeScript#49837 or microsoft/TypeScript#45213 for more insights.

In such cases, it is advisable to provide explicit type annotations at points where the compiler faces circularity. By defining recursive types beforehand, like below:

type Audit = DormNode<{ user: () => User }>
type User = DormNode<{ name: DormEdge, audits: () => Audit }>

You can then annotate either Audit or User to enable successful type checking:

const Audit: Audit = new DormNode({
  user: () => User
})
const User: User = new DormNode({
  name: new DormEdge(PredicateType.STRING),
  audits: () => Audit
});

This workaround may seem labor-intensive, but in complex scenarios involving recursive types, proactively guiding the compiler with manual annotations is crucial. While alternate strategies may exist to streamline the process, situations like these call for a hands-on approach to resolving complexities instead of relying solely on automated solutions.

Explore code on TypeScript Playground

Answer 2

The algorithm used by TypeScript for type inference operates on a heuristic basis, meaning that if it encounters a loop while trying to deduce a type, it will default to an implicit any. This heuristic approach generally handles common circular dependencies found in real-world code effectively. However, there are scenarios where it falls short, requiring a major revamp of the inference process to incorporate full unification, as discussed in microsoft/TypeScript#30134. Yet, this overhaul is unlikely due to the extensive effort it would entail and the potential decline in IDE performance for common use cases.

In situations where the compiler struggles to analyze code due to circular references, humans often find it straightforward to resolve these issues manually. Despite users reporting such circularities as bugs on TypeScript's GitHub repository, they are typically categorized as design limitations rather than defects. Comments from developers often emphasize that the current implementation is a balance between accuracy and resource allocation. Refer to examples like microsoft/TypeScript#49837 or microsoft/TypeScript#45213 for more insights.

In such cases, it is advisable to provide explicit type annotations at points where the compiler faces circularity. By defining recursive types beforehand, like below:

type Audit = DormNode<{ user: () => User }>
type User = DormNode<{ name: DormEdge, audits: () => Audit }>

You can then annotate either Audit or User to enable successful type checking:

const Audit: Audit = new DormNode({
  user: () => User
})
const User: User = new DormNode({
  name: new DormEdge(PredicateType.STRING),
  audits: () => Audit
});

This workaround may seem labor-intensive, but in complex scenarios involving recursive types, proactively guiding the compiler with manual annotations is crucial. While alternate strategies may exist to streamline the process, situations like these call for a hands-on approach to resolving complexities instead of relying solely on automated solutions.

Explore code on TypeScript Playground

Discussing recursive types A <--> B with generics in TypeScript

Answer №1

Similar questions

The property slider in the d3 slider package is not found in the type 'types of d3'

Having trouble locating the error in my Angular and Spring Security application

Caution: Updating a component is not possible during the rendering of another component. ReactJS

Is the return value a result of destructuring?

Typescript raises a error notification regarding the absence of a semicolon when importing a JSON module

How to dynamically modify ion-list elements with Ionic on button click

Reorganize code in JavaScript and TypeScript files using VSCode

An error has occurred in the Next.js App: createContext function is not defined

Error message: "Lazy-loaded modules encounter a TypeError stating that '' is not a function when accessed through NGINX."

A better choice than Java's <? super SomeType> in Typescript

There is a delay in updating ng-if/ng-hide in real time on the HTML page

What is the correct regex expression for validating decimal numbers between 1.0 and 4.5?

What steps do I need to take for webpack to locate angular modules?

Error message in Angular 2 RC-4: "Type 'FormGroup' is not compatible with type 'typeof FormGroup'"

Mapping through multiple items in a loop using Javascript

Merging Two JSON Objects into a Single Object Using Angular 4-6

Creating sophisticated TypeScript AngularJS directive

Manipulating an Array of Objects based on conditions in Angular 8

Get the @types definition installed from a forked repository

Angular ngFor Directive Failing to Display Menu Item Information on Right-Click Context Menu