Type for constructor function

[vkurchatkin]

It seems that Class type is not covariant:

Given

class A {
  a: string;
  b: string;

  constructor() {
    this.a = 'a';
    this.b = 'b';
  }
}

type AType = {
  a: string
};

This fails: const Clazz: Class<AType> = A;

 18: const Clazz: Class<AType> = A;
                                 ^ property `b` of A. Property not found in
 18: const Clazz: Class<AType> = A;
                        ^^^^^ object type

[jeffmo]

Unfortunately this isn't actually intended to work -- but we're giving a poor error message for it :(

Because classes are typed nominally in Flow, this error message should really say that it is invalid to use Class< > on any type that doesn't represent the instance of a class. In other words, because AType is an object type, using it with Class< > would mean generating a type for a specific class-object that produces instances of AType -- which would then be useless (since it exists only in the type system and not at runtime).

Sorry for the confusion here -- I don't think we actually have a way to generically specify structural class types. Maybe you can go into your use case a bit so we can understand it better?

[vkurchatkin]

@jeffmo I see, I probably misunderstood what Class actually does. There is probably a problem with the docs, then, as they state the following:

Class<T> Describes the type of the class object that would instantiate an instance of T

It should probably say "instance of class T"

Although it's weird, cause if I add b:string to AType this code actually type-checks.

Maybe you can go into your use case a bit so we can understand it better?

It's simple: I want to have a map of constructors that produce objects of type T, so that I can implement a factory that picks a constructor, calls it and returns value of type T.

To be precise, I don't need class type, I need a constructor type, i.e. a function that can be called with new, but I don't see a way to declare those as well.

I started with the following:

const map: { [key: string]: Class<MyType> } = { foo: MyConstructor }

Since it didn't work, I ended up wrapping constructors with functions:

const map: { [key: string]: (arg: any) => MyType } = { foo: arg => new MyConstructor(arg) }

It kind of makes sense, since Class<T> doesn't indicate in any way what arguments should be passed to constructor.

[jeffmo]

It should probably say "instance of class T"

Good point, I'll fix this wording. Thanks

Although it's weird, cause if I add b:string to AType this code actually type-checks.

Yes, this is actually a bug in Flow. We've known about it for a bit, but it's been so obscure that we haven't gotten to it yet.

I want to have a map of constructors that produce objects of type T, so that I can implement a factory that picks a constructor, calls it and returns value of type T.

This makes a lot of sense, thanks. I'll log this as a feature request