是否可以在TypeScript中定义类型安全的句柄？

Question

I'd like to be able to define a type-safe equivalent to a HANDLE or HWND in TypeScript. The use case is instantiating a concrete type which is provided to the user as an opaque type, who's only use is as input to other API functions. Something like the following:

 module foo {

    export
        class Handle<T> {
    }

    class Property extends Handle<Property>
    {
        constructor(public value = 12) { super(); }

    }

    export interface IProperty { }

    export function makeProperty(): Handle<IProperty> {
        return new Property();
    }

    export function getPropertyValue(p: Handle<IProperty>) {
        return (<Property>p).value;
    }

}


module bar {
    var s = foo.makeProperty();
    var p = foo.getPropertyValue(12); // this should be a compile error
}

I've been encountering 2 issues:

1. You can't return an object of a type you haven't exported. This is why I'm returning the value as an empty interface type.
2. Any value implements the empty interface or empty class. This seems to make it impossible to create a type-safe opaque handle.

Has anyone done something like this before?

Answer 1

Why it is not an error

For

var p = foo.getPropertyValue(12); // this should be a compile error

Its not a compile error since TypeScript uses a structural type system instead of a nominal type system that you might be used to from C#/JAVA etc.

What this means is that two types are compatible if their members (structure) match up irrespective of the name (nominal). Eg the following is okay

class Foo{}

var foo:Foo = 123; // okay since number contains everything that a Foo needs (which is nothing)

But the following is not okay:

class Foo{
    bar:number;
}

var foo:Foo = 123; // Error NOT okay since number doesn't contain member bar

To make it a compile error

Just add some property unique to Handle that doesn't exist on invalid types. Eg I added the property value:number below which causes the compile error as expected:

module foo {

    export class Handle<T> {
        constructor(public value:number){}
    }

    class Property extends Handle<Property>
    {
        constructor(public value = 12) { super(value); }

    }

    export interface IProperty { }

    export function makeProperty(): Handle<IProperty> {
        return new Property();
    }

    export function getPropertyValue(p: Handle<IProperty>) {
        return (<Property>p).value;
    }

}


module bar {
    var s = foo.makeProperty();
    var p = foo.getPropertyValue(12); // Compile Error
}