Creating a contravariant function member in TypeScript?

Question

Creating a contravariant function member in TypeScript?

I am facing a challenge with a class that contains a member which is a function taking an instance of the same class:

class Super {
    public member: (x: Super) => void = function(){}
    use() {const f = this.member; f(this)}
}

However, I need the member to be contravariant so that subclass instances can accept member values that are functions taking that specific subclass, like this:

class Sub extends Super {
    method() {}
}

const sub = new Sub();
sub.member = function(x: Sub) {x.method()};

Yet, TypeScript rightfully raises an error:

Type '(x: Sub) => void' is not assignable to type '(x: Super) => void'.
  Types of parameters 'x' and 'x' are incompatible.
    Property 'method' is missing in type 'Super' but required in type 'Sub'.

Is there a way to declare member such that it allows a covariant parameter type in subclasses?

My attempts to solve this have included:

I know that using method syntax to declare member (member(s: Super) {/* ... */}) would make it bivariant, but this doesn't work when member may be a collection of functions (e.g., my actual code involves a dictionary of such functions:
```
{[name: string]: (/*...*/, s: Super) => /*...*/}
```
).

I tried redeclaring member in Sub with a more restrictive signature:

class Sub extends Super {
    public member: (x: Sub) => void = function(x){x.method()};
    method() {}
}

But TypeScript still rejects it:

Property 'member' in type 'Sub' is not assignable to the same property in base type 
'Super'.
  Type '(x: Sub) => void' is not assignable to type '(x: Super) => void'.
    Types of parameters 'x' and 'x' are incompatible.
      Property 'method' is missing in type 'Super' but required in type 'Sub'.

I am aware that TypeScript now supports the in and out modifiers on templates for co/contravariance, but I am unsure if they apply here and how to modify the declaration of Super accordingly.
I prefer not to disable strictFunctionTypes as it is generally helpful and I don't want users of this library to adjust their settings just to assign to .member on subclass instances.
If all else fails, I can resort to casting the assigned values as (x: Super) => void, but this removes safeguards against incorrect assignments to different subclasses, resulting in runtime failures like this:
```
class Sub1 extends Super {
    method1() {}
}
class Sub2 extends Super {
    method2() {}
}

const sub1 = new Sub1();
sub1.member = function(x: Sub2) {x.method2()} as (x: Super) => void;
```
This code is accepted by TypeScript but fails at runtime.
Browsing through related questions, I came across a similar query involving interfaces rather than subclasses, but the answers provided are not formal yet. Furthermore, the linked snippets seem to rely on explicitly listing all subtypes, which is impractical for situations where there are numerous subclass variations.

typescript subclass covariant contravariant

Answer 1

Answer №1

If you're looking for a way to utilize the polymorphic this type, which essentially functions as an implicit generic type parameter always constrained to the "current" class, then it's like this: within the body of the Super class, the this type represents "some subtype of Super", while inside the Sub class body it represents "some subtype of Sub". When it comes to instances of Super, the this type will be associated with Super, and for Sub instances, it'll be linked with Sub.

In essence, within the class body, this behaves akin to a generic parameter; outside of the class body, it functions as though that parameter has been explicitly assigned with a type argument corresponding to the present object type.

This realization leads to the desired outcome with the sample code provided:

class Super {
    public member: (x: this) => void = function () { } 
    use() { const f = this.member; f(this) }
}

class Sub extends Super {
    method() { }
}

const sub = new Sub();
sub.member = function (x: Sub) { x.method() }; // works fine

Looks solid.

Keep in mind that a similar behavior can be achieved by using generics more directly (employing a recursive, F-bounded constraint reminiscent of Java):

class Super<T extends Super<T>> { 
    public member: (x: T) => void = function () { }
    use(this: T) { const f = this.member; f(this) } 
}

class Sub extends Super<Sub> {
    method() { }
}

const sub = new Sub();
sub.member = function (x: Sub) { x.method() };

Although somewhat less elegant, this approach offers additional flexibility if standalone this types alone don't align with your requirements.

Playground link to code

Answer 2

If you're looking for a way to utilize the polymorphic this type, which essentially functions as an implicit generic type parameter always constrained to the "current" class, then it's like this: within the body of the Super class, the this type represents "some subtype of Super", while inside the Sub class body it represents "some subtype of Sub". When it comes to instances of Super, the this type will be associated with Super, and for Sub instances, it'll be linked with Sub.

In essence, within the class body, this behaves akin to a generic parameter; outside of the class body, it functions as though that parameter has been explicitly assigned with a type argument corresponding to the present object type.

This realization leads to the desired outcome with the sample code provided:

class Super {
    public member: (x: this) => void = function () { } 
    use() { const f = this.member; f(this) }
}

class Sub extends Super {
    method() { }
}

const sub = new Sub();
sub.member = function (x: Sub) { x.method() }; // works fine

Looks solid.

Keep in mind that a similar behavior can be achieved by using generics more directly (employing a recursive, F-bounded constraint reminiscent of Java):

class Super<T extends Super<T>> { 
    public member: (x: T) => void = function () { }
    use(this: T) { const f = this.member; f(this) } 
}

class Sub extends Super<Sub> {
    method() { }
}

const sub = new Sub();
sub.member = function (x: Sub) { x.method() };

Although somewhat less elegant, this approach offers additional flexibility if standalone this types alone don't align with your requirements.

Playground link to code

Creating a contravariant function member in TypeScript?

Answer №1

Similar questions

Is it possible to create a distinctive property value within an ngFor loop that operates autonomously across two child components?

The class-transformer malfunctioning: The transformation function is not being executed

Can I assign a value from the tagModel to ngx-chips in an Angular project?

Why is it necessary to merge an interface with a function when using the new keyword?

Navigating Angular: Uncover the Secrets of Unwrapping Json Data

Issue with manipulating element styles using jQuery in Angular2

Using variables within the useEffect hook in ReactJS

Implementing individual NGRX Selectors for each child component to enable independent firing

Leveraging Java and TypeScript code for specific functionalities within an Ionic 2 Android application

Combine a pair of select statements to utilize the RxJS store within an Angular Guard

Does the React memo function modify the component's prop type?

What is the best way to call a method within a TypeScript class using its name as a string while already inside the class itself?

Combining platform-express and platform-fastify for optimal performance

Improving the management of user input in Lit components

Issue with rendering images retrieved from JSON data

How is it possible to utilize type assertions with literals like `false`?

Transforming this JavaScript function using Template Strings into TypeScript

incomplete constructor for a generic class

Tips for extracting information from a TypeScript JSON document

Can an Angular 2 module export an interface?