One interesting feature of Typescript is function overloading, and it's possible to create a constant function with multiple overloads like this:
interface FetchOverload {
(action: string, method: 'post' | 'get'): object;
(action: string): object
}
const fetch: FetchOverload = (action: string, method: 'get' | 'post' = 'get'): object { ... }
However, if I want to specify the type of response expected, instead of just using any object, I can simply replace it with the desired type:
interface FetchOverload {
(action: string, method: 'post' | 'get'): UserResponse;
(action: string): UserResponse
}
const fetch: FetchOverload = (action: string, method: 'get' | 'post' = 'get'): UserResponse { ... }
If I want to take it a step further and allow for any type of response, I could use a generic type:
interface FetchOverload<T> {
(action: string, method: 'post' | 'get'): T;
(action: string): T
}
const fetch: FetchOverload<T> = (action: string, method: 'get' | 'post' = 'get'): T { ... }
The issue arises when trying to declare a generic type T within a const. There seems to be no straightforward way to do so, leading me to explore different options:
<T> const fetch: ...
const <T> fetch: ...
const fetch <T>: ...
const fetch: <T> FetchOverload<T> = ...
const fetch: FetchOverload<T> = <T> (action: ...)
After attempting various approaches, the only solution I found was to transform the constant function into native functions with overload support:
function fetch<T>(action: string, method: 'post' | get'): T;
function fetch<T>(action: string): T;
function fetch<T>(action: string, method: 'post' | 'get' = 'get'): T { ... }
My question remains whether this is the best approach or if there are other solutions to maintain the use of const.