Better support for type bounds in generics

[jklmli]

This is currently valid, legal TypeScript:

class Container<A> {
  constructor(private value: A) {}

  act<B extends A>(b: B) { /*...*/ }
}

But reversing the type bound in act doesn't work, i.e.

act<A extends B>(b: B) { /*...*/ }

is not valid.

Ideally, the class's generic parameter can be used in any position.

---

Alternatively, we could support lower type bounds through a new keyword, narrows:

act<B narrows A>(b: B) { /*...*/ }

(meaning, B is a supertype of A).

Another possible alternative syntax:

act<B where { A extends B }>(b: B) { /*...*/ }

---

Examples of implementations in other languages:
http://rustbyexample.com/generics/where.html
http://docs.scala-lang.org/tutorials/tour/lower-type-bounds.html

[aluanhaddad]

It would definitely be great to enable this scenario to be correctly typed correctly

const xs = [{ a: 'A' }];
const ys = [{ a: 'A', b: 'B' }];

const zs = ys.concat(xs);

currently this is an error because xs is not assignable to ys. However, since a new array is returned and this new array can be safely treated as having the type typeof xs it would be nice to allow it.
EDIT:
This is perfectly possible today with

declare global {
  interface Array<T> {
    concat<A extends B, B>(this: A[], ...items: B[][]): B[];
    concat<A extends B, B>(this: A[], ...items: (B | B[])[]): B[];
  }
}

no new features required.

The problem with removing the current error is that it drastically changes the meaning of existing code where a type parameter is being shadowed

class Container<A> {
  constructor(value: A) { }

  act<A extends B, B>(b: B) { /*...*/ }
}

I'm not sure what the right notation is but where seems to read intuitively.

See also #1394.

[akarzazi]

@jiaweihli can you please share the real code behind this need ?
I wonder how can this be useful.

Aluan Haddad (@aluanhaddad)
const zs = xs.concat(ys); is more suitable.

[aluanhaddad]

Adel KARZAZI (@akarzazi) correct, but they do not mean the same thing.

[aluanhaddad]

I just realized that I can already accomplish what I want, trivially, with the following

declare global {
  interface Array<T> {
    concat<A extends B, B>(this: A[], ...items: B[][]): B[];
    concat<A extends B, B>(this: A[], ...items: (B | B[])[]): B[];
  }
}

@jiaweihli I believe you can do the same:

class Container<A> {
  constructor(private value: A) { }

  act<A extends B, B>(this: Container<A>, b: B) { /*...*/ }
}

[akarzazi]

Aluan Haddad (@aluanhaddad) you mean:

  interface Array<T> {
    concat<T extends B, B>(this: T[], ...items: B[][]): B[];
    concat<T extends B, B>(this: T[], ...items: (B | B[])[]): B[];
  }

Edit:

  interface Array<T> {
    concat<T extends B, B>(...items: B[]): B[];
    concat<T extends B, B>(...items: (B | B[])[]): B[];
  }

[aluanhaddad]

Adel KARZAZI (@akarzazi) it doesn't actually matter if the type parameter name is A or T because the intoduced T is shadowing the T from Array<T> so the this type is being annotated with a new type parameter either way.

[akarzazi]

Aluan Haddad (@aluanhaddad) see edit

[aluanhaddad]

I'm not sure I follow you. The definitions without a this type don't work correctly in several scenarios.

const zs = ys.concat(xs);

that gives zs the type { a: string }[][] but { a: string }[] is what it should be.
But this declaration

interface Array<T> {
    concat<T extends U, U>(this: T[], ...items: U[][]): U[];
    concat<T extends U, U>(this: T[], ...items: (U | U[])[]): U[];
}

infers the lower bound. Note that the method level T shadows the outer type parameter.

[akarzazi]

Aluan Haddad (@aluanhaddad) Sorry I didn't open VS to check.

interface Array<T> {
    add2<T extends B, B, C>(...items: B[]): B[];
    add3<A extends B, B>(this: A[],...items: B[]): B[];
  }

interface Type { 
    a: string;
}

interface SubType  extends Type { 
    b: string;
}

var a: SubType[] = [];

let baseTypeInst: Type = { a: "a" };
let notBaseTypeInst: Event;
a.add2(baseTypeInst); // ok 
a.add2(notBaseTypeInst); // No error!

a.add3(notBaseTypeInst); // error: subtype is not assignable to the type Event

It seems that T in the method shadows the outer T. (As you said)

It's worth mentioning that in C# behaves similarly

    public class MyClass<T> where T : ICloneable
    {
        public void Do<T>(T param)  //Warning	CS0693	
        {
            param.Clone(); // Clone is not defined on param
        }
    }

   public interface IMyClass<T> where T : ICloneable
    {
        void Do<T>(T param); //Warning	CS0693	
    }

but there is a warning :

Warning CS0693 Type parameter 'T' has the same name as the type parameter from outer type 'MyClass'

[jklmli]

Aluan Haddad (@aluanhaddad) Yup, the code you posted sets lower bounds correctly.

[jyuhuan]

Aluan Haddad (@aluanhaddad) I have a follow up question. Consider the following function in some generic class,

foo<A extends B, B>(b: B) { /* ... */ }

As your code above suggested, this ensures that B is a superclass of A.

But what if A is not a type parameter. What if it is some actual class that is already defined? For example, if I already have the following classes

class Animal {}
class Cat extends Animal {}
class Kitten extends Cat {}

What should I do if I want to enforce that B should be a super class of Kitten? Clearly writing

foo<Kitten extends B, B>(b: B) { /* ... */ }

won't work because this is trying to declare a new type parameter named Kitten, instead of using the class Kitten.