TS2322 error: What does it mean when the type is both not assignable and assignable?

Question

TS2322 error: What does it mean when the type is both not assignable and assignable?

I've been delving into the world of generics with Java and C#, but TypeScript is throwing me for a loop. Can someone shed some light on this confusion?

constructor FooAdapter(): FooAdapter

Type 'FooAdapter' is not assignable to type 'A'.

'FooAdapter' is assignable to the constraint of type 'A', but 'A' could be instantiated with a different subtype of constraint 'FooAdapter'.

ts(2322)

Troubleshooting from the code snippet below:

interface IFoo {}

interface IAdapter<F extends IFoo> {
   getFoo():F
}

abstract class AbstractFoo<F extends IFoo> {
   abstract something<A extends IAdapter<F>>():A;
}


class Foo implements IFoo {}
class FooAdapter implements IAdapter<Foo> {
   getFoo() { return new Foo(); }
}

class FooFactory extends AbstractFoo<Foo> {
   something<A extends FooAdapter>():A {
      return new FooAdapter();  // <--- ts(2322) here
   }   
}

Suggestions on resolving this issue?

typescript generics

Answer 1

Answer №1

An issue arises when FooAdapter is not A, rather it can only be the parent class of A.

You have two options to resolve this:

A) Modify something's return to be more generic, allowing it to accept new FooAdapter():

interface IFoo {}

interface IAdapter<F extends IFoo> {
   getFoo():F
}

abstract class AbstractFoo<F extends IFoo> {
   abstract something(): IAdapter<F>;
}


class Foo implements IFoo {}

class FooAdapter implements IAdapter<Foo> {
   getFoo() { return new Foo(); }
}

interface IHasEmptyConstructor<T> {
    new(): T
}

class FooFactory extends AbstractFoo<Foo> {
   something(): IAdapter<Foo> {
      return new FooAdapter();
   }   
}

const fooFactory = new FooFactory();

fooFactory.something();

B) Alter something to return A instead of FooAdapter:

interface IFoo {}

interface IAdapter<F extends IFoo> {
   getFoo():F
}

abstract class AbstractFoo<F extends IFoo> {
   abstract something<A extends IAdapter<F>>(adapter: IHasEmptyConstructor<A>):A;
}


class Foo implements IFoo {}

class FooAdapter implements IAdapter<Foo> {
   getFoo() { return new Foo(); }
}

interface IHasEmptyConstructor<T> {
    new(): T
}

class FooFactory extends AbstractFoo<Foo> {
   something<A extends FooAdapter>(adapter: IHasEmptyConstructor<A>): A {
      return new adapter();
   }   
}

const fooFactory = new FooFactory();

fooFactory.something(FooAdapter);

Answer 2

An issue arises when FooAdapter is not A, rather it can only be the parent class of A.

You have two options to resolve this:

A) Modify something's return to be more generic, allowing it to accept new FooAdapter():

interface IFoo {}

interface IAdapter<F extends IFoo> {
   getFoo():F
}

abstract class AbstractFoo<F extends IFoo> {
   abstract something(): IAdapter<F>;
}


class Foo implements IFoo {}

class FooAdapter implements IAdapter<Foo> {
   getFoo() { return new Foo(); }
}

interface IHasEmptyConstructor<T> {
    new(): T
}

class FooFactory extends AbstractFoo<Foo> {
   something(): IAdapter<Foo> {
      return new FooAdapter();
   }   
}

const fooFactory = new FooFactory();

fooFactory.something();

B) Alter something to return A instead of FooAdapter:

interface IFoo {}

interface IAdapter<F extends IFoo> {
   getFoo():F
}

abstract class AbstractFoo<F extends IFoo> {
   abstract something<A extends IAdapter<F>>(adapter: IHasEmptyConstructor<A>):A;
}


class Foo implements IFoo {}

class FooAdapter implements IAdapter<Foo> {
   getFoo() { return new Foo(); }
}

interface IHasEmptyConstructor<T> {
    new(): T
}

class FooFactory extends AbstractFoo<Foo> {
   something<A extends FooAdapter>(adapter: IHasEmptyConstructor<A>): A {
      return new adapter();
   }   
}

const fooFactory = new FooFactory();

fooFactory.something(FooAdapter);

TS2322 error: What does it mean when the type is both not assignable and assignable?

Answer №1

Similar questions

Why is TypeScript resorting to using 'any' for specific prop type definitions in React?

Tips for resolving type checking errors in TypeScript and React

Determine the type of embedded function by analyzing the callback

Encountering the error message "Unable to access properties of null (specifically 'useState')" while trying to utilize a component from my custom library

Unlocking the power of asynchronous methods within the useEffect() hook

When emitting an event multiple times in Angular, an error may occur where properties of undefined are unable to be read, particularly in relation to the "

Issues with Angular not reflecting data changes in the view after updates have occurred

"An issue has been noticed with Discord.js and Discordx VoiceStateUpdate where the return

What is the reason behind taps in TypeScript only registering the first tap event?

Chart of commitments and potential outcomes

Issue found in React Js test - TypeError: source.on does not exist as a function

Neither Output nor EventEmitter are transmitting data

Maintaining checkbox selection while switching pages in Angular

The declaration file for module 'react/jsx-runtime' could not be located

What is the best way to create a universal limitation for a larger collection of a discriminated union?

Issues encountered when attempting to use Angular2 with SystemJs and typescript transpiler

Angular Unit testing error: Unable to find a matching route for URL segment 'home/advisor'

Sharing references in React Native using TypeScript: The (property) React.MutableRefObject<null>.current is potentially null

When iterating through a table, an error occurs stating that the property "rows" is not available on type HTMLElement (

Experimenting with nested dual dynamic routing within the app's directory