Additional generic type constraints

[5ebastianMeier]

I'm trying to produce method signatures where I can provide an interface as a generic type parameter and have a regular parameter that has a constraint on implementing that interface.

doSomething<U, T implements U>(myParam: T): void {
   ...
}

interface IDemo {
   look(): void;
}

class Demo implements IDemo {
   look(): void {
      ...
   }
}

thisShouldWork(): void {
   doSomething<IDemo>(Demo); // this is the type - not an instance
}

As far as I know this is currently not possible in TypeScript.

The two things I'm missing are:

• a generic type constraint implements that enables a better use of interfaces
• a type check that does not depend on an instance, but works with the pure type

With the current implementation of TypeScript I cannot use a type as an actual value to a constrained parameter - I have to create a instance of it for the type check to work

doSomething<U>(myParam: U): void {
   ...
}

interface IDemo {
   look(): void;
}

class Demo implements IDemo {
   look(): void {
      ...
   }
}

thisShouldWork(): void {
   const instance = new Demo();
   doSomething<IDemo>(Demo); // error
   doSomething<IDemo>(instance); // works
}

I have a strong C# background so I might be a bit spoiled of the generic type constraints there, but the C# implementation enabled me to do everything that I imagined possible with generics.

If there are no technical obstacles that make these features hard or even impossible to implement, I think that could leverage TypeScript to give developers the same power as C# does - especially when building frameworks.

These sure are not all scenarios for additional generic type constraints, but the ones I really have been missing so far.

[HerringtonDarkholme]

Please read the FAQ. https://github.com/Microsoft/TypeScript/wiki/FAQ#why-cant-i-write-typeof-t-new-t-or-instanceof-t-in-my-generic-function

And the doc. https://www.typescriptlang.org/docs/handbook/interfaces.html#class-types

https://www.typescriptlang.org/play/index.html#src=function%20doSomething%3CU%3E(myParam%3A%20%7Bnew%20(...args)%3A%20U%7D)%3A%20void%20%7B%0D%0A%7D%0D%0A%0D%0Ainterface%20IDemo%20%7B%0D%0A%20%20%20%20look()%3A%20void%3B%0D%0A%7D%0D%0A%0D%0Aclass%20Demo%20implements%20IDemo%20%7B%0D%0A%20%20%20look()%3A%20void%20%7B%0D%0A%20%20%20%7D%0D%0A%7D%0D%0A%0D%0Afunction%20thisShouldWork()%3A%20void%20%7B%0D%0A%20%20%20doSomething%3CIDemo%3E(Demo)%3B%20%2F%2F%20this%20is%20the%20type%20-%20not%20an%20instance%0D%0A%7D

[5ebastianMeier]

@HerringtonDarkholme thanks for the hint on the trick with the constructor - but that's something different from what I meant.

My proposal aimed to provide design time type safety - not a runtime type safety like in your example with instanceof and keywords like that.

I know that all generic type information is lost during compilation, but that's not a problem.
During design time this can really help to ensure that when a developer expects a class to implement a certain interface - it actually does.

[HerringtonDarkholme]

I'm sorry I cannot get your point.

a type check that does not depend on an instance, but works with the pure type

My understanding is that you want to check a new (): T constructor type. That is, Demo returns a IDemo compatible instance. Other than a constructor you cannot express a type in JavaScript, the subset and compilation target of TypeScript. So constructor type is enough for TypeScript.

For example, in this example.
doSomething<IDemo>(Demo) guarantees Demo implements IDemo, otherwise Demo does not return an instance compatible with IDemo. Online demo

all generic type information is lost during compilation
And
an interface as a generic type parameter and have a regular parameter that has a constraint on implementing that interface.

And doSomething<IDemo>(Demo); is a function call in runtime. You have to represent type in runtime, which is constructor in this case.

Or, is your point simply

If a function has genertic parameter reads <T implments SomeInterface>, then T must be declared as class T implments SomeInterface. The implments clause is required.

[agalazis]

@5ebastianMeier I think extends is a legit solution in this case(If I got your point). Java also shares a "similar" (not sure if I can put more quotes, I understand that's two different worlds) view: https://docs.oracle.com/javase/tutorial/java/generics/bounded.html
The part where it mentions:
"Note that, in this context, extends is used in a general sense
// to mean either "extends" (as in classes) or "implements" (as in interfaces)."
Thanks for mentioning though. Not sure if there is any official typescript doc that mentions using extends for both in that case, but I also think that it makes sense in typescript(for different reasons: because any class that implements an interface also implements an interface with superset of properties, and therefore that interface extends the interface implemented by the class )