Typescript overload arrow functions

This solution is based on @Sam96 but keeps the code of the arrow function fully typed.

type Create = {
  (): Vector<0>;
  <T>(x: T): Vector<T>;
  <T>(x: T, y: T): Vector<T>;
};

const create: Create = <T>(
  x?: T,
  y?: T
) => ({
  x: x ?? 0,
  y: y ?? x ?? 0,
});

I guess it was added inbetween then and now, because you can do it now using an interface or type (doesnt matter, same syntax except the keyword). Also works as export of course. The function has to be named though (i think all overloaded functions have to), so you'll have to declare it first if you want to use it as callback.

type IOverload = {
    (param: number): number[];
    (param: object): object[];
}

const overloadedArrowFunc: IOverload = (param: any) => {
    return [param, param];
}

let val = overloadedArrowFunc(4);

I far prefer it like that, it reduces the need for duplicate writing. Writing the name again and again is annoying.

Also, to preface any questions regarding that, yeah I've declared the parameter as any in the implementation. This is neccessary at the current state to allow compilation, and yeah, you will loose type-safety inside the function, as @ford04 pointed out. It seems typescript still cant process flagged unions correctly when it comes to functions and their returns. Alternatively you can have stricter parameters but then you will have to cast the return to any.

The declaration of overloaded signatures is always

function name(args...): result;

with a function keyword and a function name.

Your syntax

var myMethodArror = (param: string): string;

is invalid. It is trying to assign something that looks like the beginning of an arrow function to a variable, but the function has no body. You will get the error

'=>' expected

If you repeat this with a a different signature, then you'll also get a duplicate property error, or perhaps the error

Subsequent variable declarations must have the same type.

This is not specific to arrow functions. The same problem would arise if you tried to do

var myMethodArror = function(param: string): string;

which would yield

'{' expected

since the function body is missing.

You can use intersection operator & for overloading.

export let myMethodArror = ((param: string | number): string | number => {
...
}) as ((param: string) => string) & ((param: number) => number)