Polymorphic/generic this as return type for subclasses

[f1ames]

I know this PR title sounds a little cryptic because well... it's not easy to explain but I will try.

The issue

The main issue this PR is trying to solve is as follows. Image we have a generic base class which methods can return new instances of itself:

class BaseClass<T> {
    public value: T;

    constructor(value: T) {
        this.value = value;
    }

    method1(value: T): BaseClass<T> {
        return new BaseClass<T>(value);
    }

    method2<U>(value: U): BaseClass<U> {
        return new BaseClass<U>(value);
    }
}

And extending class:

class DerivedClass<T> extends BaseClass<T> {
    test: () {
        console.log(this);
    }
}

So now any call to derivedClassInstance.methodX() should return DerivedClass instance. Unfortunately, with the code above it will always return BaseClass instance:

const bc = new BaseClass(1);
bc.method1(2); // returns BaseClass<number>
bc.method2("foo"); // returns BaseClass<string>

const dc = new DerivedClass(1);
dc.method1(2); // returns BaseClass<number> but should return DerivedClass<number>
dc.method2("foo"); // returns BaseClass<string> but should return DerivedClass<string>

Approaches

I spend some time looking into what we can do and how to handle this. I will talk a bit about some ideas.

Let's solve this with this

If you look back at the above code, BaseClass.method1() could be written as:

    method1(value: T): BaseClass<T> {
        this.value = value;
        return this;
    }

This partially solves the issue as calling dc.method1(2); will now return this (which is dc in runtime). However:

• For methods changing generic type (like .method2() above) it's not really working.
• Still TS will show (static code analysis / during compile time) that dc.method1() returns BaseClass<T> as method signature says.
• It also means that TS will complain about dc.method1().test() (even though it works in the runtime).

Dynamic approach using TS utility functions

The idea was to somehow dynamically generate return type with TS ReturnType utility, something like:

    method1(value: T): ReturnType<() => typeof this.constructor> {
        return new BaseClass<T>(value);
    }

It doesn't have to be this.constructor it could be any property or method of the class we can fully control. However, using this in such context is prohibited by TS - Return type of public method from exported class has or is using private name 'this'. And AFAIU this basically make it impossible to use any construct with this (so any field, method, etc) to dynamically type methods return type. And this is the only thing we could rely on to deduce type here.

Static approach and some typing

Since TS is statically typed language I tired more static approach with a lot of typing (typing as on keyboard)... 😝 Anyway...

It requires methods overloading and duplicating them in subclasses. This is the approach which lead me the closest to a working solution.

The solution

From what I understand what we want to achieve is called "polymorphic generic this" or higher-kinded types (see 1, 2 and 3) 🤔 I'm not sure though 🤔

And as for the above I've found two (related) issues in TypeScript tracker which describes similar/same concepts - microsoft/TypeScript#6223 and microsoft/TypeScript#4967 (comment). AFAIU it's not really feasible to achieve this with clean and more dynamic approach.

There are in fact two issues to be solved - this and return type should be a correct class instance during runtime. And TypeScript compiler should also understand the code and correct return type (so it can compile the code without errors and generate correct TS typings). This are in fact two separate issues where one doesn't necessary solve the other.

This PR contains src/generic-this-1.ts file which shows the approach I have used on abstract classes. And so:

Returning correct class instance during runtime

Instead of creating new instance directly in "common" methods, let's extract create method like:

class BaseClass<T> {
    public value: T;

    constructor(value: T) {
        this.value = value;
    }

    create<U>(value: U): BaseClass<U> {
        return new BaseClass<U>(value);
    }

    method1<U>(value: U): BaseClass<U> {
        return this.create<U>(value);
    }
}

then in derived class we can simply override it so it creates instance of this class:

class DerivedClass<T> extends BaseClass<T> {
    create<U>(value: U): DerivedClass<U> {
        return new DerivedClass<U>(value);
    }
}

and now DerivedClass instance will be correctly returned:

const dc = new DerivedClass(123);
dc.method1(456); // returns DerivedClass<number> instance

Make TS understand what's going on

Still TS will complain that dc.method1(456); returns BaseClass<T> and so we need to override method1 like:

class DerivedClass<T> extends BaseClass<T> {
    create<U>(value: U): DerivedClass<U> {
        return new DerivedClass<U>(value);
    }

    method1<U>(value: U): DerivedClass<U> {
        return super.method1<U>(value) as DerivedClass<U>;
    }
}

And now both during compile time and runtime we have correct return type. It also generates correct TS typings.

Wait... there is more

What if we have derived class with "fixed" type:

class BaseClassFixedType extends BaseClass<string> {}

This requires a similar approach but since create and method1 will not be generic here, it needs correct overloading in BaseClass:

class BaseClass<T> {
    public value: T;

    constructor(value: T) {
        this.value = value;
    }

    create(value: T): BaseClass<T>;
    create<U>(value: U): BaseClass<U>;
    create<U>(value: U): BaseClass<U> {
        return new BaseClass<U>(value);
    }

    method1(value: T): BaseClass<T>;
    method1<U>(value: U): BaseClass<U>;
    method1<U>(value: U): BaseClass<U> {
        return this.create<U>(value);
    }
}

and then in derived class we use only non-generic version:

class BaseClassFixedType extends BaseClass<string> {
    create(value: string): BaseClassFixedType {
        return new BaseClassFixedType(value);
    }

    method1(value: string): BaseClassFixedType {
        return super.method1(value) as BaseClassFixedType;
    }
}

Now BaseClassFixedType instance will be correctly returned:

const bcft = new BaseClassFixedType("foo");
bcft.method1("bar); // returns BaseClassFixedType instance

Please see src/generic-this-1.ts file which contains the full code with sample calls too.

Wait... there is more

Kind of... 😅 The issue I found so far with the above approach is that fixed derived class can't use generic overloaded method version. So the below code will fail:

const bcft = new BaseClassFixedType("foo");

bcft.method1("bar"); // Works fine

bcft.method1(123); // "Argument of type 'number' is not assignable to parameter of type 'string'."

---

The above is reflected in changes done in DataStream and StringStream classes. And well, it works 🎉

This PR doesn't solve the issue with mutating stream in/out types (as described in #23 (comment)) but it is a necessary "intro" we need to have to solve it correctly. That's also the reason why map was left untouched for now.

Unit tests introduced in this PR checks both runtime types (instanceof and constructor.name) as well as compile time types (by trying to call .split() method on resulting stream which fails if it is not a StringStream decalred return type).

[scramjet-bot]

Task linked: CU-1j4fnf5 Przemyśleć generyki - metody obiektowe (map, filter, ...)

[ErykSol]

Nicely done!!!

[jan-warchol]

Good job!! 👍 🥇

[f1ames]

Moved generic-this-1.ts to samples folder. Added changes description to fixing commit.

[f1ames]

Rebased onto latest main.