Myujth

Or how do you define multiple signatures for a returned function

I'm trying to make a curried function but I'm having trouble with the definition overloads. In specific if you call parallelMap with one argument, you can call the next argument with 1 or 2 arguments. However the def is marked as invalid.

[ts] Overload signature is not compatible with function implementation. [2394]

export function parallelMap<T, R> (concurrency: number): (func: (data: T) => R | Promise<R>) => (iterable: AnyIterable<T>) => AsyncIterableIterator<R>

Full implementation;

export function parallelMap<T, R> (concurrency: number): (func: (data: T) => R | Promise<R>, iterable: AnyIterable<T>) => AsyncIterableIterator<R>
export function parallelMap<T, R> (concurrency: number): (func: (data: T) => R | Promise<R>) => (iterable: AnyIterable<T>) => AsyncIterableIterator<R>
export function parallelMap<T, R> (concurrency: number, func: (data: T) => R | Promise<R>): (iterable: AnyIterable<T>) => AsyncIterableIterator<R>
export function parallelMap<T, R> (concurrency: number, func: (data: T) => R | Promise<R>, iterable: AnyIterable<T>): AsyncIterableIterator<R>
export function parallelMap<T, R> (
 concurrency: number,
 func?: (data: T) => R | Promise<R>,
 iterable?: AnyIterable<T>,
) 
 if (func === undefined) 
 return <A, B>(curriedFunc: (data: A) => B 
 if (iterable === undefined) 
 return (curriedIterable: AnyIterable<T>) => parallelMap<T, R>(concurrency, func, curriedIterable)
 
 return _parallelMap<T, R>(concurrency, func, iterable)

Thanks!

Overloads are useful when different parameter types should result in different return types. It's not useful to have two different overload signatures with the same parameter types. That's because, as the handbook says:

[The compiler] looks at the overload list, and proceeding with the first overload attempts to call the function with the provided parameters. If it finds a match, it picks this overload as the correct overload.

Your first two overloads have the same parameter types, so the second overload will never be used. That means if you call parallelMap() with one argument, it will return a two-argument function and that's it. It does not return a one-argument function.

Let's remedy that. The solution here is when you call parallelMap() with one argument, you want to return an overloaded function, instead of a function of just one argument or just two arguments.

Additionally, you want the generic type parameters to be on that returned function, since when you call parallelMap(concurrency) you don't know at that point what T and R will end up being.

So replace those first two signatures with this:

export function parallelMap(concurrency: number): 
 <T,R>(func: (data: T) => R 

Now that says "if you call parallelMap() with one argument, it will return another function which can be called with two arguments of type XXX and YYY and return ZZZ, and it can also be called with one argument of type XXX and return a function from YYY to ZZZ."

Now it should mostly work. Notice that because you are using overloads, the following code isn't exactly correct:

 if (func === undefined) 
 return <A, B>(
 curriedFunc: (data: A) => B 

After all, none of the overload call signatures accept a possibly undefined third argument. You either call it with two or three defined arguments. So you should change that to something like:

 if (func === undefined) 
 return <A, B>(
 curriedFunc: (data: A) => B 

which calls two different overloads of parallelMap() depending on whether curriedIterable is defined.

Okay, hope that helps. Good luck!