What circumstances allow for the exclusion of "generic types" in TypeScript?

Question

What circumstances allow for the exclusion of "generic types" in TypeScript?

There seems to be inconsistency in how the TypeScript compiler handles parametrised types. Sometimes it raises an error if a type is not passed, other times it doesn't, and the reasoning behind this behavior is unclear.

It appears that the structure of the function may influence whether the compiler can infer the type T, but there are instances where this assumption does not hold true.

Several experiments were conducted to test this theory:

Experiment 1

function cannotBeInferred<T>(): T {
  return 0 as T;
}

const a1 = cannotBeInferred();
const a2 = cannotBeInferred<string>();

Variable a1 is inferred as unknown; an unexpected outcome
Variable a2 is correctly inferred as string

Experiment 2

function canBeInferredNativeType<T>(par: T): T {
  return par;
}

const b1 = canBeInferredNativeType('test');
const b2 = canBeInferredNativeType<string>('test');

Variable b1 is of type "test", which should generate an error
Variable b2 is correctly inferred as string

Experiment 3

function canBeInferredInterface<T>(param: { something: T }): T {
  return param.something;
}

interface Something { something: string };
const param: Something = { something: 'blabla' };

const c1 = canBeInferredInterface({ something: 'test' });
const c2 = canBeInferredInterface(param);
const c3 = canBeInferredInterface<number>({ something: 123 });

Variable c1 is inferred as string, despite potential ambiguity
Variable c2 is also inferred as string, which could benefit from clearer error handling
Variable c3 is correctly inferred as number

This inconsistency calls for a more uniform approach. Is there a compiler option available to achieve this?

typescript

Answer 1

Answer №1

One interesting aspect of Typescript is the ability to exclude generic type parameters under certain conditions:

If they are optional, meaning a default value has been set
```
type Type<Optional = string> = .....
```
=> you can utilize Type without explicitly stating the generic parameter, which will default to string
If they can be inferred and not partially specified

type Func<Input, Return> = (input: Input) => Return;

const hoist = <Input, Return>(func: Func<Input, Return>, input: Input) => {

 return func(input);
}

const hoistReturnNumber = <Input, Return = number>(func: Func<Input, Return>, input: Input) => {

 return hoist<Input, Return>(func, input);
}

// fully inferrable, no specifications => OK
hoist((a: string) => parseInt(a), '12')

// specifying first parameter, leaving second optional => OK
hoistReturnNumber<string>((a: string) => parseInt(a), '12')

// fully inferrable with first parameter specified while second required => ERROR
hoist<string>((a: string) => parseInt(a), '12')

// fully specified
hoist<string, number>((a: string) => parseInt(a), '12')

Although it may seem an obsessive-compulsive behavior trigger, having inferred generic parameters enables deep inference and truly versatile code that does not necessitate arduous refactoring when types involved undergo changes.

Answer 2

One interesting aspect of Typescript is the ability to exclude generic type parameters under certain conditions:

If they are optional, meaning a default value has been set
```
type Type<Optional = string> = .....
```
=> you can utilize Type without explicitly stating the generic parameter, which will default to string
If they can be inferred and not partially specified

type Func<Input, Return> = (input: Input) => Return;

const hoist = <Input, Return>(func: Func<Input, Return>, input: Input) => {

 return func(input);
}

const hoistReturnNumber = <Input, Return = number>(func: Func<Input, Return>, input: Input) => {

 return hoist<Input, Return>(func, input);
}

// fully inferrable, no specifications => OK
hoist((a: string) => parseInt(a), '12')

// specifying first parameter, leaving second optional => OK
hoistReturnNumber<string>((a: string) => parseInt(a), '12')

// fully inferrable with first parameter specified while second required => ERROR
hoist<string>((a: string) => parseInt(a), '12')

// fully specified
hoist<string, number>((a: string) => parseInt(a), '12')

Although it may seem an obsessive-compulsive behavior trigger, having inferred generic parameters enables deep inference and truly versatile code that does not necessitate arduous refactoring when types involved undergo changes.

What circumstances allow for the exclusion of "generic types" in TypeScript?

Answer №1

Similar questions

Creating a JSON object from an array of data using TypeScript

Limit the keys of an object to only those present in the provided array

Encountering Error TS2411 when upgrading from Typescript version 1.0.0 to 1.1.0-1

React's componentDidUpdate being triggered before prop change occurs

Error in React Typescript Order Form when recalculating on change

Guide to accessing references in a nested v-for loop using Vue 3, Typescript, and the Composition API

Problem with ngStyle: Error indicating that the expected '}' is missing

Utilizing Vue 3 with TypeScript for enforcing type checking on single file components' props

Material UI Error TS1128: Expected declaration or statement for ButtonUnstyledProps

Guide to leveraging tanstack table v8 for sorting data within a specific date range

Distinguishing Between TypeScript Interface Function Properties

Encountering a Angular 12 Observable<Object[]> Error while attempting to execute a GET request

Organize JSON data in Angular 6 from an observable based on a specific key

In what scenario would one require an 'is' predicate instead of utilizing the 'in' operator?

Is it possible to have a button within a table that, when clicked, opens a card overlaying the entire table?

Utilize a single component across various instances for enhanced efficiency

Parent dropdown passes selected value to child component for triggering various API calls

What is the reason behind providing self-references in Typescript interfaces?

What could be causing the absence of the exported Object when importing into a different Typescript project?

Is it possible to utilize an @Input() in Angular with multiple types?