Optimizing a TypeScript Curry Function: From Static Types to Variadic Types

Currying is a functional programming technique that transforms a function with multiple arguments into a sequence of functions, each taking a single argument. This approach is particularly useful for creating more modular and reusable functions, allowing for partial application of arguments. In TypeScript, implementing an efficient curry function requires careful type management, especially when dealing with a variable number of arguments.

In this article, we'll explore two different implementations of a curry function in TypeScript. The first uses interfaces with static types, while the second adopts a more flexible approach using a single interface with variadic types. We’ll analyze the differences between these two implementations and discuss the advantages of the more optimized approach.

Initial Implementation: Interfaces with Static Types

Defining the Interfaces

In the first implementation, I defined a series of interfaces to handle curried functions with varying numbers of arguments. Each interface corresponds to a function with a specific number of arguments:

interface CurryFunction1<T1, R> {
    (arg1: T1): R;
}

interface CurryFunction2<T1, T2, R> {
    (arg1: T1): CurryFunction1<T2, R>;
}

interface CurryFunction3<T1, T2, T3, R> {
    (arg1: T1): CurryFunction2<T2, T3, R>;
}

interface CurryFunction4<T1, T2, T3, T4, R> {
    (arg1: T1): CurryFunction3<T2, T3, T4, R>;
}

interface CurryFunction5<T1, T2, T3, T4, T5, R> {
    (arg1: T1): CurryFunction4<T2, T3, T4, T5, R>;
}

interface CurryFunction6<T1, T2, T3, T4, T5, T6, R> {
    (arg1: T1): CurryFunction5<T2, T3, T4, T5, T6, R>;
}

Implementing the Curry Function

The curry function is defined to use these interfaces to curry functions with up to six arguments:

function curry<T1, T2, R>(fn: (arg1: T1, arg2: T2) => R): CurryFunction2<T1, T2, R>;
function curry<T1, T2, T3, R>(fn: (arg1: T1, arg2: T2, arg3: T3) => R): CurryFunction3<T1, T2, T3, R>;
function curry<T1, T2, T3, T4, R>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R): CurryFunction4<T1, T2, T3, T4, R>;
function curry<T1, T2, T3, T4, T5, R>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => R): CurryFunction5<T1, T2, T3, T4, T5, R>;
function curry<T1, T2, T3, T4, T5, T6, R>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => R): CurryFunction6<T1, T2, T3, T4, T5, T6, R>;
function curry(fn: Function) {
    return function curried(...args: any[]) {
        if (args.length >= fn.length) {
            return fn(...args);
        } else {
            return (...args2: any[]) => curried(...args, ...args2);
        }
    };
}

Testing the Curry Function

This function is then tested to ensure it works correctly with different numbers of arguments:

function testCurry() {
    const add = (a: number, b: number) => a + b;
    const curriedAdd = curry(add);
    assert(curriedAdd(1)(2) === 3, 'Test curry function with 2 arguments');

    const add3Args = (a: number, b: number, c: number) => a + b + c;
    const curriedAdd3Args = curry(add3Args);
    assert(curriedAdd3Args(1)(2)(3) === 6, 'Test curry function with 3 arguments');
}

Analysis of the Implementation

While this implementation is clear and typical of TypeScript, it has some limitations. Notably, it requires the definition of multiple interfaces for each possible number of arguments, making the code redundant and harder to maintain. Additionally, handling more than six arguments would require adding more interfaces, increasing complexity.

Optimized Implementation: Single Interface with Variadic Types

Introduction to Variadic Types

To optimize the curry function, I adopted a more dynamic approach using a single generic interface with variadic types. This approach allows handling an arbitrary number of arguments without needing to define a separate interface for each case.

Implementing the Curry Function with Variadic Types

In this optimized version, the curry function is implemented using a single generic interface that leverages TypeScript's variadic types to handle an arbitrary number of arguments:

type CurryFunction<T extends unknown[], R> = T extends [infer A, ...infer Rest]
  ? (arg: A) => CurryFunction<Rest, R>
  : R;

function curry<T extends unknown[], R>(fn: (...args: T) => R): CurryFunction<T, R> {
  return function curried(...args: unknown[]): unknown {
    if (args.length >= fn.length) {
      return fn(...args as T);
    } else {
      return (...args2: unknown[]) => curried(...([...args, ...args2] as unknown[]));
    }
  } as CurryFunction<T, R>;
}

Benefits of the Optimized Implementation

1. Reduced Complexity: By using a single generic interface CurryFunction, this implementation eliminates the need to create multiple interfaces for every possible number of arguments. This makes the code more concise and easier to maintain.

2. Support for an Arbitrary Number of Arguments: Leveraging variadic types allows this function to curry functions with any number of arguments without modifying the implementation. The function is thus more flexible and adaptable to various scenarios.

3. Improved Typing: Dynamic typing allows TypeScript to accurately infer argument types, providing stronger type checking during development, reducing the risk of errors, and improving code completion.

Testing the Optimized Curry Function

This version of the curry function is also tested to ensure it functions correctly:

function testCurry() {
    const add = (a: number, b: number) => a + b;
    const curriedAdd = curry(add);
    assert(curriedAdd(1)(2) === 3, 'Test curry function with 2 arguments');

    const add3Args = (a: number, b: number, c: number) => a + b + c;
    const curriedAdd3Args = curry(add3Args);
    assert(curriedAdd3Args(1)(2)(3) === 6, 'Test curry function with 3 arguments');

    const add4Args = (a: number, b: number, c: number, d: number) => a + b + c + d;
    const curriedAdd4Args = curry(add4Args);
    assert(curriedAdd4Args(1)(2)(3)(4) === 10, 'Test curry function with 4 arguments');
}

Optimizing the curry function in TypeScript demonstrates how an approach based on static interfaces can be improved by adopting variadic types. The new implementation not only reduces code complexity but also offers greater flexibility and stronger type checking. This example highlights the importance of fully leveraging TypeScript’s capabilities to create cleaner, more modular, and maintainable code.

Transitioning from a structure with multiple interfaces to a single generic interface is a great example of how understanding and applying advanced TypeScript concepts can lead to more elegant and efficient solutions.