curry.ts

export type Curry<F extends (...args: readonly unknown[]) => unknown> = 
  Parameters<F> extends readonly [infer First, ...infer Rest]
    ? (arg: First) => Rest extends readonly []
      ? ReturnType<F>
      : Curry<(...args: Rest) => ReturnType<F>>
    : ReturnType<F>;

export function curry<F extends (...args: readonly unknown[]) => unknown>(fn: F): Curry<F> {
  function curried(...providedArgs: readonly unknown[]): unknown {
    if (providedArgs.length >= fn.length) {
      return fn(...(providedArgs.slice(0, fn.length) as Parameters<F>));
    }
    
    return (...newArgs: readonly unknown[]) => {
      return curried(...providedArgs, ...newArgs);
    };
  }
  
  return curried as Curry<F>;
}

enum SomeType {
  A = 'A',
  B = 'B',
}

type TypeMap = {
  [SomeType.A]: string;
  [SomeType.B]: number;
}

// Simple overloaded function signatures
function useReactive<T extends SomeType.A>(
  fn: (...args: unknown[]) => unknown,
  type: T
): string;

function useReactive<T extends SomeType.B>(
  fn: (...args: unknown[]) => unknown,
  type: T
): number;

// Implementation
function useReactive<T extends keyof TypeMap>(
  fn: (...args: unknown[]) => unknown,
  type: T
): TypeMap[T] {
  const result = fn();
  
  switch (type) {
    case SomeType.A:
      return String(result) as TypeMap[T];
    case SomeType.B:
      return Number(result) as TypeMap[T];
    default:
      throw new Error(`Unsupported type: ${type}`);
  }
}

// Usage - hover over these to see the correct types
const a = useReactive(() => "test", SomeType.A); // Type: string
const b = useReactive(() => 42, SomeType.B);     // Type: number

enum SomeType {
  A = 'A',
  B = 'B',
}

type TypeMap = {
  [SomeType.A]: string;
  [SomeType.B]: number;
}

type ReactiveFunction<T> = (...args: unknown[]) => T;

function useReactive<T extends keyof TypeMap>(
  fn: (...args: unknown[]) => unknown,
  type: T
): ReactiveFunction<TypeMap[T]>;

function useReactive<T extends keyof TypeMap>(
  fn: (...args: unknown[]) => unknown,
  type: T
): ReactiveFunction<TypeMap[T]> {
  
  return (...args: unknown[]): TypeMap[T] => {
    const result = fn(...args);
    
    switch (type) {
      case SomeType.A:
        return String(result) as TypeMap[T];
      case SomeType.B:
        return Number(result) as TypeMap[T];
      default:
        return result as TypeMap[T];
    }
  };
}

// Usage
const a = useReactive(() => 42, SomeType.A); // Type: (...args: unknown[]) => string
const b = useReactive(() => "hello", SomeType.B); // Type: (...args: unknown[]) => number

// When you call them:
const stringResult = a(); // Type: string
const numberResult = b(); // Type: number