class constraints

I am looking for a way to get my derived class be inherited from a generic class.
This is my naive attempt to get it:

export function create<T>(base: { new (value: string): T }) {
  return new class extends base {
    constructor() {
      super('hey');
    }
  };
}

It might be that I am just doing it wrong, but looks like a current limitation, if so:

allow class expressions to be declared with a constructor function that returns a generic class

It might require a new syntax for class constraints:

export function create<class T>(base: { new (value: string): T }) {
  return new class extends base {
    constructor() {
      super('hey');
    }
  };
}

How would TS check that the anonymous class is compatible with base, when base is determined at run time?

Eg

class Foo {
    public fooMethod(x:number):string { return 'hello'; }
}

export function create<T>(base: { new(): T }) {
  return new class extends base {
      public fooMethod(x:string):void {}
  };
}

create<Foo>(Foo);

The anonymous class is overriding the fooMethod() with an incompatible signature, but there is nothing in the signature of create() that should prohibit Foo from filling T. You would need to somehow express in the signature of create() that T must either not have a fooMethod or has a fooMethod with a signature that (x:string):void is compatible with (i.e. the override will be compatible).

A good question, it is certainly possible:

at the time of calling create when the type parameter T gets resolved to a real type
or declaratively in the signature of create by constraining T unlike C where C is the type of the anmonitors class: negating type constraints #7993

Anders Hejlsberg (@ahejlsberg)

Seems that Anders Hejlsberg (@ahejlsberg) already shown some workaround for the problem described by Aleksey-Bykov, could not find, though.

Aleksey-Bykov, I completely agree that we need something like that. However Jesse Schalken (@jesseschalken) is also right. I'd propose other solution, that can look way to far from your solution (class constraint) but will help to solve the same problem.

I would propose the special type constructor: T overrides U
It is not a constraint, it is a type. So you freely can write:

var a: {x: number} overrides {x: {}, y: boolean}; 
    // and get the correct { x: number, y: boolean}

As well as

var X: TExtension overrides TBase; 
  // where both TExtension and TBase are generic type params

This operator ensures that extension is correct at the instantiation time.

var a: {x: number} overrides {x: string, y: boolean}; 
   // error:  number and string are not compatible

Guys, what do you think?

Jesse Schalken (@jesseschalken)

in my case, Jesse Schalken (@jesseschalken) example would look like:

export function create<T>(base: new() => T }): {
  fooMethod(x: string): void
} overrides T {
  return new class extends base {
      public fooMethod(x:string):void {}
  };
}

class Foo {
    public fooMethod(x:number):string { return 'hello'; }
}

create<Foo>(Foo); // error at compile time

Ryan Cavanaugh (@RyanCavanaugh)

For all actual types T and U the type T overrides U inferred exactly according to the TypeScript member overriding rules.

ping Ryan Cavanaugh (@RyanCavanaugh)

I like overrides

looks like a duplicate of #4890

Mohamed Hegazy (@mhegazy)

Mohamed Hegazy (@mhegazy) - exactly, it's that duplicate I've tried to find. Aleksey-Bykov let's go there and move the process forward -)

Navigation Menu

Repository navigation

class constraints #9776

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

class constraints #9776

Description

Activity

jesseschalken commented on Jul 17, 2016

zpdDG4gta8XKpMCd commented on Jul 17, 2016

Artazor commented on Jul 17, 2016

Artazor commented on Jul 17, 2016

Artazor commented on Jul 17, 2016

zpdDG4gta8XKpMCd commented on Jul 17, 2016

mhegazy commented on Jul 17, 2016

Artazor commented on Jul 17, 2016

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions