It is not necessary to specify a generic type on a Typescript class

Question

It is not necessary to specify a generic type on a Typescript class

When working with Typescript and default compiler options, there are strict rules in place regarding null values and uninitialized class attributes in constructors. However, with generics, it is possible to define a generic type for a class and create a new instance of the class without specifying the type!

class Foo<T> {
    bar(item: T): void {
        console.log('typeof T: ', typeof item)
    }
}

const foo1 = new Foo<string>() // Type 'T' specified
foo1.bar('hello')
foo1.bar(6) // error TS2345: Argument of type '6' is not assignable to parameter of type 'string'

const foo2 = new Foo() // Type 'T' not specified
foo2.bar('hello')
foo2.bar(6) // Works without error

Could new Foo() be considered incorrect?

In this case, I am using default compiler options that do not allow adding an extra attribute a: T which would never be initialized.

typescript class generics

Answer 1

Answer №1

To prevent the omission of T from causing an error in the constructor, you can utilize conditional type magic along with a constructor that requires at least one argument.

If no argument is provided, you can render the class unusable by setting a default for the type parameter. Setting the default to never will effectively achieve this.

class Foo<T = never> {
    bar(item: T): void {
        console.log('typeof T: ', typeof item)
    }
}

const foo1 = new Foo<string>() // Specified T
foo1.bar('hello')
foo1.bar(6) // Error TS2345: Argument of type '6' is not assignable to parameter of type 'string'

const foo2 = new Foo() // Missing T
foo2.bar('hello') // Error
foo2.bar(6) // Error

An alternative approach is to use a constructor overload and rest parameters with tuples. This will result in an error if the type parameter is omitted (meaning it defaults to never).

class Foo<T = never> {
    constructor(...a: T extends never ? ['No T was specified']:[])
    constructor() {

    }
    bar(item: T): void {
        console.log('typeof T:', typeof item)
    }
}

const foo1 = new Foo<string>() // Specified T
foo1.bar('hello')
foo1.bar(6) // Error TS2345: Argument of type '6' is not assignable to parameter of type 'string'

const foo2 = new Foo() // Missing T, error!
foo2.bar('hello') // Error
foo2.bar(6) // Error

Answer 2

To prevent the omission of T from causing an error in the constructor, you can utilize conditional type magic along with a constructor that requires at least one argument.

If no argument is provided, you can render the class unusable by setting a default for the type parameter. Setting the default to never will effectively achieve this.

class Foo<T = never> {
    bar(item: T): void {
        console.log('typeof T: ', typeof item)
    }
}

const foo1 = new Foo<string>() // Specified T
foo1.bar('hello')
foo1.bar(6) // Error TS2345: Argument of type '6' is not assignable to parameter of type 'string'

const foo2 = new Foo() // Missing T
foo2.bar('hello') // Error
foo2.bar(6) // Error

An alternative approach is to use a constructor overload and rest parameters with tuples. This will result in an error if the type parameter is omitted (meaning it defaults to never).

class Foo<T = never> {
    constructor(...a: T extends never ? ['No T was specified']:[])
    constructor() {

    }
    bar(item: T): void {
        console.log('typeof T:', typeof item)
    }
}

const foo1 = new Foo<string>() // Specified T
foo1.bar('hello')
foo1.bar(6) // Error TS2345: Argument of type '6' is not assignable to parameter of type 'string'

const foo2 = new Foo() // Missing T, error!
foo2.bar('hello') // Error
foo2.bar(6) // Error

Answer 3

Answer №2

In addition to the previous responses, it is worth mentioning that TSLint has a specific guideline addressing this issue: no-inferred-empty-object-type

Implementing this guideline will prompt TSLint to flag instances where TypeScript assumes {} as a generic type (similar to the noImplicitAny compiler option, but for generics).

This rule appears to align with your requirements.

Answer 4

In addition to the previous responses, it is worth mentioning that TSLint has a specific guideline addressing this issue: no-inferred-empty-object-type

Implementing this guideline will prompt TSLint to flag instances where TypeScript assumes {} as a generic type (similar to the noImplicitAny compiler option, but for generics).

This rule appears to align with your requirements.

Answer 5

Answer №3

One interesting feature is the ability to create a new class without explicitly defining its type when a generic type is already set for the original class!

This concept is known as type argument inference:

This means that the compiler can automatically determine the value of T based on the type of the argument we provide.

Therefore

Is it considered incorrect to create a new Foo() without specifying the type?

No, because the compiler may assign T as any or string | number depending on your existing code, making T perfectly valid.

Considering your code:

const foo2 = new Foo() // T missing
foo2.bar('hello')
foo2.bar(6) // no issues

Why would there be any problems? The compiler needs to infer a type by analyzing all instances to determine a suitable type. What sets apart the previous snippet from this one:

const foo3 = new Foo() // T missing
foo3.bar(6) 
foo3.bar('hello') // no complaints

The only distinction lies in the sequence of actions. Why should the compiler assume that only the first method usage defines the type of T? Consider this scenario:

const foo3 = new Foo() // T missing
if (someValueOrBooleanReturningFunction) {
  foo3.bar(6) 
}
foo3.bar('hello') // no issues

What then? It could or couldn't ascertain the if condition's value, but since no type is specified, the compiler must deduce the value of T.

Answer 6

One interesting feature is the ability to create a new class without explicitly defining its type when a generic type is already set for the original class!

This concept is known as type argument inference:

This means that the compiler can automatically determine the value of T based on the type of the argument we provide.

Therefore

Is it considered incorrect to create a new Foo() without specifying the type?

No, because the compiler may assign T as any or string | number depending on your existing code, making T perfectly valid.

Considering your code:

const foo2 = new Foo() // T missing
foo2.bar('hello')
foo2.bar(6) // no issues

Why would there be any problems? The compiler needs to infer a type by analyzing all instances to determine a suitable type. What sets apart the previous snippet from this one:

const foo3 = new Foo() // T missing
foo3.bar(6) 
foo3.bar('hello') // no complaints

The only distinction lies in the sequence of actions. Why should the compiler assume that only the first method usage defines the type of T? Consider this scenario:

const foo3 = new Foo() // T missing
if (someValueOrBooleanReturningFunction) {
  foo3.bar(6) 
}
foo3.bar('hello') // no issues

What then? It could or couldn't ascertain the if condition's value, but since no type is specified, the compiler must deduce the value of T.

It is not necessary to specify a generic type on a Typescript class

Answer №1

Answer №2

Answer №3

Similar questions

The correct way to incorporate a global property into a component template (using Vue 3, Vite, TypeScript, and the Composition API)

How to efficiently filter an array containing nested objects using TypeScript

Is it necessary for me to set up @types/node? It appears that VSCode comes with it pre-installed

Angular 6 combined with Firebase is experiencing difficulties with routing after a successful login

The concept of TypeScript usage within the `mui-x` DataGrid while calling the `useGridApiRef()` function

Identifying the scenario where Partial<T> inherits from T

Comparing attribute selectors to class selectors in the realm of styling

Angular - Enabling the next screen button only after completing multiple selections

I am unfamiliar with this scenario but I can utilize Axios, async/await, and TypeScript to navigate it

What is the proper way to specify the type for a <video> element reference in React when utilizing Typescript?

How can I pass DOCUMENT in Angular?

Jest is having trouble recognizing a custom global function during testing, even though it functions properly outside of testing

React Router malfunctioning on production environment when integrated with an Express backend

Nativescript encountered an issue while attempting to generate the application. The module failed to load: app/main.js

Documentation for npm package that has been published

Angular input box with integrated datepicker icons displayed inside

What could be causing my TSC to constantly crash whenever I try to utilize MUI props?

What is the best way to convert JSON into a complex object in Typescript and Angular?

Consecutive HTTP requests in Angular using rxjs

Guide to simulating Twilio with Jest and TypeScript to perform unit testing