Manipulating and passing structures of the same type in class methods

Question

Manipulating and passing structures of the same type in class methods

Can you advise on the proper way to write this class?

class X {
    f(): this {
        return this;
    }

    g(): { a: this } {
        return { a: this };
    }

    h(obj: {a: this}): this {
        return obj.a;
    }
}

Issue encountered in ts playground:

A 'this' type is available only in a non-static member of a class or interface.

I could simply use X as the type, but I intend for these methods to correctly infer the type when X extends another parent class and when another child class extends X.

typescript

Answer 1

Answer №1

After analyzing the discussion on this GitHub thread, it seems that the issue at hand is similar to dealing with polymorphic "this" in static methods, even when those methods are actually instance methods.

Drawing from that insight, it looks like this solution might do the trick...

  g<T extends this>(this: T): { a: T } {
    return {a: this};
  }

Answer 2

After analyzing the discussion on this GitHub thread, it seems that the issue at hand is similar to dealing with polymorphic "this" in static methods, even when those methods are actually instance methods.

Drawing from that insight, it looks like this solution might do the trick...

  g<T extends this>(this: T): { a: T } {
    return {a: this};
  }

Answer 3

Answer №2

One way to tackle the issue is by incorporating generics into the methods and allowing for flexibility in defining this.

class Y {
    z(): this {
        return this;
    }

    m<U extends unknown>(this: U): { b: U } {
        return { b: this };
    }

    n<V extends unknown>(object: {b: V}): V {
        return object.b;
    }
}

Answer 4

One way to tackle the issue is by incorporating generics into the methods and allowing for flexibility in defining this.

class Y {
    z(): this {
        return this;
    }

    m<U extends unknown>(this: U): { b: U } {
        return { b: this };
    }

    n<V extends unknown>(object: {b: V}): V {
        return object.b;
    }
}

Manipulating and passing structures of the same type in class methods

Answer №1

Answer №2

Similar questions

Incorporating Google Pay functionality within Angular applications

Can TypeScript be used to annotate a string consisting only of letters in the alphabet?

What factors contribute to TypeScript having varying generic function inference behaviors between arrow functions and regular functions?

Trouble arises when trying to navigate to a new page from ion-tabs within Ionic 2

Eliminate any values that have not been chosen from the dropdown array in ngx-select-dropdown

The process of invoking the parent class's Symbol.iterator function from the child class's Symbol.iterator can be achieved by following a specific

The promise of returning a number is not compatible with a standalone number

Testing private methods in Angular

Exploring the power of Angular 4/5 with Render2 through Jasmine testing

The child component fails to inherit the data types provided by the parent component

Continuously extract information by filtering through the array

"Implementing a retry feature for Angular http requests triggered by a button

How about: "Loop through an array of objects fetched from an observable and initiate an HTTP request for each object's ID?"

The validation process in reactive forms is experiencing some issues with efficiency

Unexpected expression after upgrading to TypeScript 3.7.2 was encountered, file expected.ts(1109)

The orderBy filter seems to be malfunctioning

What is the best method to utilize the UMD module included in a minified JavaScript file within a React

Is it necessary to enforce a check for surplus properties in the return type of a function

Angular is known to raise the error ExpressionChangedAfterItHasBeenCheckedError

Are npm @types packages causing issues in Visual Studio?