Function from class to class

[futpib]

How do I properly annotate the following code?

const AMixin = superclass => class extends superclass {
  aMixedMethod() {}
}

const ABMixin = superclass => class extends AMixin(superclass) {
  bMixedMethod() {}
}

export {
  AMixin,
  ABMixin,
};

This example on flow.org/try.

Analogous code without exports works fine with inferred types (example), but I am not sure what the inferred signature is or how to get it or whether it is possible.

[wulibaye]

learn

[madbence]

@futpib I think AMixin and ABMixin have Class<*> => Class<*> types. You can read about Class<T> here and about type * here.

[futpib]

@madbence Thanks, I thought so too! I tried using *. But with both * or Class<*> strange things start to happen if you split AMixin and ABMixin to separate modules. Here comes the more-or-less actual use-case that made me open this issue 😄.

b.js:5
  5: const ABMixin = (superclass: Class<*>): Class<*> => class extends AMixin(superclass) {
                                                                              ^^^^^^^^^^ class expr `<<anonymous class>>`. This type is incompatible with the expected param type of
  7: const A = AMixin(class {});
                      ^^^^^^^^ class expr `<<anonymous class>>`. See: a.js:7

Same happens for both * → * and Class<*> → Class<*>. I think it might be due to the *-inference being local to the module it is used in. So the actual exported inferred type becomes Class<"<<anonymous class>>"> where anonymous class is the one used in a.js, which is different from one that is used in b.js.

Here is a demo repo since you can't add multiple files on flow.org/try https://github.com/futpib/flow-3915 (master is for Class<*>, star branch is for *)

// a.js
// @flow

const AMixin = (superclass: Class<*>): Class<*> => class extends superclass {
    aMethod() {}
};

const A = AMixin(class {});

export { AMixin, A };

// b.js
// @flow

import { AMixin } from './a';

const ABMixin = (superclass: Class<*>): Class<*> => class extends AMixin(superclass) {
    bMethod() {}
};

const AB = ABMixin(class {});

export { ABMixin, AB };

And when used inside a single module * works just fine.