Typescript does not automatically infer the generic types

Question

Typescript does not automatically infer the generic types

Just delving into typescript and attempting to create a parser combinator library. Initially, handling types and generics was straightforward until I encountered an issue.

// Representing the returned value of the parser with generic T
class Parser<T> {
    ...
}

// Merging two parsers into one tuple using this function
function pair<P1 extends Parser<A>, P2 extends Parser<B>, A, B>(
  parser1: Parser<A>,
  parser2: Parser<B>
): Parser<{ fst: A, snd: B }> {
    ...
}

// Transforming a Parser<A> to a Parser<B> via the mapping of A => B
function map<P extends Parser<A>, F extends (a: A) => B, A, B>(
  parser: P, mapFn: F 
): Parser<B> {
    ...
}

Here arises the issue:

// Similar to `pair` but with the parser value as A instead of {fst: A, snd: B}
function left<P1 extends Parser<A>, P2 extends Parser<B>, A, B>(
  parser1: P1,
  parser2: P2
): Parser<A> {
  return map(pair(parser1, parser2), (a: unknown): A => (a as {fst: R1, snd: R2}).fs );
}

The provided `left` function compiles, however, it is unclear why typescript does not infer that the unknown should be {fst: A, snd: B}. Is this an issue with typescript or simply my misunderstanding of how typescript generics operate.
Thanks in advance.

EDIT
Added reproducible playground:
You can access the link for the reproducible code.

typescript parsing typescript-generics

Answer 1

Answer №1

To explicitly infer the Parser generic and map callback return type, you simply need to follow a few steps.

For instance:

// The generic T represents the value the parser returns
class Parser<T> { }

// Combine two parsers into one tuple
function pair<P1 extends Parser<A>, P2 extends Parser<B>, A, B>(
  parser1: Parser<A>,
  parser2: Parser<B>
): Parser<{ fst: A, snd: B }> {
  return null as any
}

type InferGeneric<T extends Parser<unknown>> = T extends Parser<infer R> ? R : never

function map<P extends Parser<A>, F extends (a: /** explicit infer generic */ InferGeneric<P>) => B, A, B>(
  parser: P, mapFn: F
): Parser<ReturnType<F>> /** Explicit ReturnType infer */ {
  return null as any
}


// Similar to pair but only returns value of type A 
function left<P1 extends Parser<A>, P2 extends Parser<B>, A, B>(
  parser1: P1,
  parser2: P2
): Parser<A> {
  return map(pair(parser1, parser2), a => 42); // ok
}

Playground

Answer 2

To explicitly infer the Parser generic and map callback return type, you simply need to follow a few steps.

For instance:

// The generic T represents the value the parser returns
class Parser<T> { }

// Combine two parsers into one tuple
function pair<P1 extends Parser<A>, P2 extends Parser<B>, A, B>(
  parser1: Parser<A>,
  parser2: Parser<B>
): Parser<{ fst: A, snd: B }> {
  return null as any
}

type InferGeneric<T extends Parser<unknown>> = T extends Parser<infer R> ? R : never

function map<P extends Parser<A>, F extends (a: /** explicit infer generic */ InferGeneric<P>) => B, A, B>(
  parser: P, mapFn: F
): Parser<ReturnType<F>> /** Explicit ReturnType infer */ {
  return null as any
}


// Similar to pair but only returns value of type A 
function left<P1 extends Parser<A>, P2 extends Parser<B>, A, B>(
  parser1: P1,
  parser2: P2
): Parser<A> {
  return map(pair(parser1, parser2), a => 42); // ok
}

Playground

Answer 3

Answer №2

Reduce the Number of Generics

When your generic type parameters are inferred as unknown, one effective strategy is to minimize the amount of generics used in your function and instead derive specific types from others.

This can sometimes be achieved by utilizing standard utility types such as ReturnType<T> to determine the return type based on a function's type T. Additionally, you can create custom utility types using conditionals with infer/extends.

In the provided example, simplification is possible by only having generic values for A and B.

class Wrapper<T> {
    callable: () => T;
    constructor(callable: () => T) {
        this.callable = callable;
    }
}

function map<A, B>(w: Wrapper<A>, mapFn: (a: A) => B): Wrapper<B> {
    return new Wrapper(() => mapFn(w.callable()));
}

function pair<A, B>(w1: Wrapper<A>, w2: Wrapper<B>): Wrapper<{fst: A, snd: B}> {
    return new Wrapper(() => ({fst: w1.callable(), snd: w2.callable()}));
}

function left<A, B>(w1: Wrapper<A>, w2: Wrapper<B>): Wrapper<A> {
    return map(pair(w1, w2), value => value.fst);
}

Typescript Playground Link

Answer 4

Reduce the Number of Generics

When your generic type parameters are inferred as unknown, one effective strategy is to minimize the amount of generics used in your function and instead derive specific types from others.

This can sometimes be achieved by utilizing standard utility types such as ReturnType<T> to determine the return type based on a function's type T. Additionally, you can create custom utility types using conditionals with infer/extends.

In the provided example, simplification is possible by only having generic values for A and B.

class Wrapper<T> {
    callable: () => T;
    constructor(callable: () => T) {
        this.callable = callable;
    }
}

function map<A, B>(w: Wrapper<A>, mapFn: (a: A) => B): Wrapper<B> {
    return new Wrapper(() => mapFn(w.callable()));
}

function pair<A, B>(w1: Wrapper<A>, w2: Wrapper<B>): Wrapper<{fst: A, snd: B}> {
    return new Wrapper(() => ({fst: w1.callable(), snd: w2.callable()}));
}

function left<A, B>(w1: Wrapper<A>, w2: Wrapper<B>): Wrapper<A> {
    return map(pair(w1, w2), value => value.fst);
}

Typescript Playground Link

Typescript does not automatically infer the generic types

Answer №1

Answer №2

Reduce the Number of Generics

Similar questions

The syntax of the input string is incorrect. #

Debugging TypeScript on a Linux environment

Is it possible to utilize a Directive for nesting content within an ng-template in Angular?

Utilizing CDK to transfer files to S3 storage bucket

Encountering the error "Cannot access property 'on' of undefined" during Angular unit testing with Karma and Jasmine

Issue encountered when attempting to assign a local variable as the initial value of an enum object member

Understanding IP Address on mobile devices with Nativescript

Decoding JSON responses using JavaScript

Problem with dynamic page routes in Next.js (and using TypeScript)

Why does TypeScript not generate an error if props are not passed to a functional component?

Challenges with implementing Typescript in Next.js and the getStaticProps function

sticky header on pinned tables in a React data grid

Angular: Streamlining the Constructor Function for Efficiency

"Utilize the simplewebauthn TypeScript library in combination with a password manager for enhanced security with passkeys

Using Typescript: Utilizing generic types within the parent class

What are some strategies for encouraging tools to embrace TypeScript's exhaustiveness checking with minimal reliance on comments?

Include a class in ul > li elements upon page load in Angular4

Using TypeScript and Vue to load a static json configuration file upon opening the index.html page

Picture is currently not displaying within a NextJS element

Encountering TypeScript errors with Apollo Server 4 during the production build process