function overloading

[fdecampredon]

I would like to express a function with the following overloading:

<B>(func: () => B): () => Promise<B>;
<A,B>(func: (a:A) => B): (a: A) => Promise<B>;

it seems to me that it is not possible since :

<A,B>(func: () => B | (a:A) => B): () => Promise<B> |  (a: A) => Promise<B>;

Does not conditionally constraint the return type, any idea ?

[avikchaudhuri]

You can try intersection types. See an example at: http://flowtype.org/docs/union-intersection-types.html#_

[gabelevi]

It's also worth noting that you might need to use parentheses to express the union or intersection of two function types.

  var a : () => A | B

is parsed as

var a : () => (A | B)

so the union of two functions is

var a : (() => A) | () => B

[fdecampredon]

Thanks.
However if you wish to support .d.ts files anyways I guess flow will need to be able to consume typescript overloading style.

[avikchaudhuri]

No doubt. Currently we do support overloading syntax, at least in some contexts. For example, you can write:

declare class C {
foo(x: number): number;
foo(x: string): string;
}

[avikchaudhuri]

The following should now work, closing.

declare function foo<B>(func: () => B): () => Promise<B>;
declare function foo<A,B>(func: (a:A) => B): (a: A) => Promise<B>;

foo(() => 0)(); // OK
foo((x: number) => "")(); // error: too few args, undefined ~/~ number

[leoasis]

Is it possible to set overloading types for function without using declare?

[Macil]

@avikchaudhuri Is there a way to do that while also defining the function?

[pronebird]

It does not work in other contexts as @leoasis pointed out. such as when defining a function. Flow is not able to select the right combo.

// @flow

type State = Array<number>;
type GetState = () => State;

type Action = { type: 'A' };
type Thunk = (dispatch: Dispatch, getState: GetState) => Promise<any>;

type Dispatch = ((action: Action) => Action) | ((action: Thunk) => Promise<any>);

const dispatch: Dispatch = (action) => {
  if(typeof action === 'function') {
    return action(dispatch, () => { return [1]; });
  }
  return action;
}

dispatch({ type: 'A' });
dispatch((dispatch, getState) => Promise.resolve());

Throws the following error:

9: type Dispatch = ((action: Action) => Action) | ((action: Thunk) => Promise<any>);
                                                            ^ function type. Callable signature not found in
18: dispatch({ type: 'A' });
             ^ object literal

11: const dispatch: Dispatch = (action) => {                               
                               ^ function. Could not decide which case to select
11: const dispatch: Dispatch = (action) => {
                    ^ union type

9: type Dispatch = ((action: Action) => Action) | ((action: Thunk) => Promise<any>);
                             ^ property `type` of object type. Property not found in
19: dispatch((dispatch, getState) => {             
             ^ function

[hackhat]

// @flow

const items = [1, 2, 3];

type FirstType = ((_: 'a') => number) & ((n: 'b') => Array<number>);

const first: FirstType = (n):any => {
  if (n === "a") {
    return items[0];
  } else if(n === 'b') {
    return items;
  }
}

const a: number = first('a');
const b: Array<number> = first('b');

Is partially working. From https://stackoverflow.com/questions/45481046/how-to-define-a-type-of-return-based-on-an-argument-string-flowtype-javascript

[morajabi]

Any progress here? I think it's a quite important feature.

[zeorin]

Interfaces seem to have the behaviour you're looking for: #3021 (comment).

[lll000111]

@zeorin Your linked example does not show how one would define a function. I'm not quite sure what it does, actually, there doesn't seem to be any Javascript, just Flow type stuff. How would one use that to do something real, with JS code? You define the function XYZ, how do you annotate it to have multiple type signatures? If you follow my linked issue, I link to examples hat use an intersection type of function signatures, but that doesn't seem to work when I introduce generics, or I don't know how to do that.

[trusktr]

Can someone please provide a fully working example (not just type-only examples)?

[trusktr]

I tried making a function intersection as people have suggested, and using it in a real implementation, but getting type errors:

flow try

Equivalent in TypeScript (no error with x + y):

typescript play

[StreetStrider]

@trusktr
This seemes to work.

[trusktr]

@StreetStrider in the previous example, if I make the implementation parameters type any, the error persists:

Flow Try

How do we fix that one?

[StreetStrider]

@trusktr
Maybe like this.

The error message remains quite good as well.

[trusktr]

That's interesting, I have not seen that method explained anywhere, including Flow docs on Overloaded functions (the example above had only types, no implementation).

declare function add (x: number, y: number): number;
declare function add (x: string, y: string): string;
function add (x: any, y: any) { // <----- IMPLEMENTATION
  if (typeof x === 'number' && typeof y === 'number')
    return x + y;
  else if (typeof x === 'string' && typeof y === 'string')
    return x + y;

  throw '';
}

add(1, 2)
add('asdf', 'asdf')

// type error (good)
add(1, 'asdf')

// type error (good)
add(true, false)

But what's the difference? Is there a bug with the intersection method?

[StreetStrider]

But what's the difference? Is there a bug with the intersection method?

I can't remember how I figured it out, but this is quite a reliable way to do this in both TS and Flow. It kind of creates proper overload, that's all I know. When you use intersection, sometimes it creates an «incorrect» intersection, considering function overload. Maybe someone with internals' knowledge can clarify.

including Flow docs

In my opinion, Flow docs was never good. There were a lot of vague spots. So a lot of info became a sort of folklore. It is good to ask questions in tracker from time to time. Sometimes someone with better knowledge may help. This is what helped me in the past.