Do Typescript generics use type erasure to implement generics?

Question

Meaning you cannot use something like this?

class Helpers
{
    static ObjectAs<T>(val: any): T {
        if (!(val instanceof T)) {
            return null;
        }

        return <T>val;
    }
}

Any workaround to get the underlying type of the generic declaration?

Update 1:

As Ryan Cavanaugh mentioned, when compiled, the whole type system is erased, more like Java's implementation of Generics. I believe .Net implementation of Generics to preserve type information in the compiled code is better than Java. However, I cannot help but wonder, why is not possible to permit full runtime introspection of generic types and generic type parameters in TypeScript? Why designers of TypeScript decided to remove all generic type information at runtime?

The following TypeScript code:

function As<T>(n: any): T {
    if (n instanceof T) {
        return n;
    } else {
        return null;
    }
}

var obj: Object = 1;
var x = As<number>(obj);

Could be translated to this JavaScript code:

function As(n, T) {
    if (n instanceof T) {
        return n;
    } else {
        return null;
    }
}

var obj = 1;
var x = As(obj, Number);

Preserving the type information at runtime and compatibility with the js code!

Update 2: I've posted the issue on CodePlex, hoping to get more from TypeScript people https://typescript.codeplex.com/discussions/550262

Answer 1

The type system is wholly erased. You can see this in the generated code for any generic function.

That said, for classes, there's still some runtime information left. You could write this:

class A { }
class B { }
function As<T>(n: any, type: { new(...args: any[]): T }): T {
    if(n instanceof type) {
        return n;
    } else {
        return null;
    }
}

var x = new A();
var y = new B();
console.log(As(x, A));
console.log(As(x, B));