Typescript – Interfaces with construct signatures not type checking

typescript

I've been playing a bit with interfaces with construct signatures in TypeScript, and I became a bit confused when the following failed to type check:

class Foo {
    constructor () {
    }
}

interface Bar {
    new(): Bar;
}

function Baz(C : Bar) {
    return new C()
}

var o = Baz(Foo);

The type error is:

Supplied parameters do not match any signature of call target:
Construct signatures of types 'new() => Foo' and 'Bar' are
incompatible: Type 'Bar' requires a construct signature, but Type
'Foo' lacks one (C: Bar) => Bar

The type of Foo's constructor is () => Foo, and that is what I thought that Bar said. Am I missing something here?

Best Answer

Here is an updated version of your code with a subtle change.

We define the Bar interface with whatever functions and variables we expect to be present.

Next, we extend the Bar interface with the NewableBar interface. This just defined a constructor that returns a Bar.

Because Foo implements Bar and has a constructor and Baz requires a NewableBar, everything is checked.

This is a little more verbose than any - but gives you the checking you want.

interface Bar {

}

interface NewableBar extends Bar {
    new();
}

class Foo implements Bar {
    constructor () {

    }
}

function Baz(C : NewableBar) {
    return new C()
}

var o = Baz(Foo);

Related Solutions

Typescript – How does interfaces with construct signatures work

Construct signatures in interfaces are not implementable in classes; they're only for defining existing JS APIs that define a 'new'-able function. Here's an example involving interfaces new signatures that does work:

interface ComesFromString {
    name: string;
}

interface StringConstructable {
    new(n: string): ComesFromString;
}

class MadeFromString implements ComesFromString {
    constructor (public name: string) {
        console.log('ctor invoked');
    }
}

function makeObj(n: StringConstructable) {
    return new n('hello!');
}

console.log(makeObj(MadeFromString).name);

This creates an actual constraint for what you can invoke makeObj with:

class Other implements ComesFromString {
    constructor (public name: string, count: number) {
    }
}

makeObj(Other); // Error! Other's constructor doesn't match StringConstructable

PHP: implode() Invalid arguments passed

Why? Why would you write a function, that calls a std function? Why not write implode(',', $array); instead of adding the overhead of a function call?

Also: What var_dump puts out an array? is it a dump of $a inside the array_implode function? To be sure $a is always going to be an array, and you insist on keeping your array_implode function, edit the code to look like this:

function array_implode(array $a)
{//type hinting: this function will only work if $a is an array
    return implode(',',$a);
}

Best Answer

Related Solutions

Typescript – How does interfaces with construct signatures work

PHP: implode() Invalid arguments passed

Related Topic