In TypeScript, there are two powerful features that allow you to define functions with return types dependent on parameter types: overloaded functions and generic functions. Both of these methods come with their own set of limitations.
Overloaded Functions
When using overloaded functions, you can have multiple call signatures for a single function. The compiler determines which signature to use based on the input parameters provided during the function call. Below is an example of how you can define an overloaded function called toggleDateString:
declare const toggleDateString: {
(value: Date): string;
(value: string): Date;
}
toggleDateString(new Date()).toUpperCase(); // results in string
toggleDateString("hello").getFullYear(); // results in Date
However, overloaded functions come with some caveats:
When implementing an overloaded function using a function statement, you need to declare each call signature first before providing the implementation. The compiler does check to some extent if the implementation matches the declared call signatures, but it may allow unsafe implementations. So caution must be exercised while writing the implementation logic inside the function statement.
If you try to implement an overloaded function using an expression like a function expression or an arrow function, the compiler might warn about seemingly safe implementations. In such cases, a type assertion may be needed to suppress errors and proceed without issues.
During function calls, the compiler only allows invoking one specific call signature at a time. It does not combine different call signatures, leading to an error if the appropriate signature cannot be determined.
Manipulating the types of overloaded functions in the type system often results in the compiler treating only the first or last call signature as existing, which sometimes has unexpected effects.
Generic Functions
With generic functions, you have a single call signature but include a generic type parameter that gets inferred based on the input types. This enables you to specify the expected return type in terms of the generic parameter. While generic functions offer more flexibility, they also come with certain complexities, especially when dealing with conditional return types.
Unlike overloaded functions, generic functions provide a cleaner approach with a centralized call signature, allowing for easier manipulation within the type system.
Keep in mind the following considerations when working with generic functions with conditional return types:
Feel free to express your preference towards overloaded or generic functions based on your coding style and project requirements.
General advice includes handling type assertions carefully to prevent errors, especially within generic function implementations.