Part 3: Closures and Currying - Function Factories

Introduction

I built an authentication middleware system that needed to validate different user roles. My first attempt used global configuration variables and duplicate code for each role check. Adding a new role required copying and modifying entire validation functions. Configuration changes broke existing validators.

I refactored using closures and currying. Created factory functions that captured configuration in closures. Curried validators took role requirements first, then user data. Adding new roles meant calling the factory with different parameters. Configuration stayed local. That's when closures and currying clicked for me.

This article teaches you to use closures for encapsulation, curry functions for flexibility, build function factories, and create reusable patterns.

Understanding Closures

A closure gives a function access to its outer scope's variables, even after the outer function has returned.

Basic Closure

function createCounter() {
    let count = 0;  // Private variable
    
    return {
        increment: () => ++count,
        decrement: () => --count,
        getValue: () => count
    };
}

const counter = createCounter();

console.log(counter.increment());  // 1
console.log(counter.increment());  // 2
console.log(counter.getValue());   // 2
console.log(counter.decrement());  // 1

// Cannot access count directly
// console.log(counter.count);  // undefined

The increment, decrement, and getValue functions "close over" the count variable, keeping it alive and private.

Multiple Closures

function createUser(name: string) {
    let loginCount = 0;
    let lastLogin: Date | null = null;
    
    return {
        getName: () => name,
        recordLogin: () => {
            loginCount++;
            lastLogin = new Date();
        },
        getStats: () => ({
            name,
            loginCount,
            lastLogin
        })
    };
}

const user = createUser('Alice');

user.recordLogin();
console.log(user.getStats());  // { name: 'Alice', loginCount: 1, lastLogin: Date }

user.recordLogin();
console.log(user.getStats());  // { name: 'Alice', loginCount: 2, lastLogin: Date }

Real Example: Configuration Management

interface DatabaseConfig {
    host: string;
    port: number;
    database: string;
    maxConnections: number;
}

function createDatabaseConnection(config: DatabaseConfig) {
    let connectionCount = 0;
    const connections = new Set<string>();
    
    return {
        connect: (clientId: string) => {
            if (connectionCount >= config.maxConnections) {
                throw new Error('Max connections reached');
            }
            
            if (connections.has(clientId)) {
                throw new Error('Client already connected');
            }
            
            connections.add(clientId);
            connectionCount++;
            
            console.log(`Connected to ${config.host}:${config.port}/${config.database}`);
            console.log(`Active connections: ${connectionCount}/${config.maxConnections}`);
        },
        
        disconnect: (clientId: string) => {
            if (connections.has(clientId)) {
                connections.delete(clientId);
                connectionCount--;
                console.log(`Disconnected. Active: ${connectionCount}/${config.maxConnections}`);
            }
        },
        
        getStatus: () => ({
            host: config.host,
            database: config.database,
            activeConnections: connectionCount,
            maxConnections: config.maxConnections,
            availableConnections: config.maxConnections - connectionCount
        })
    };
}

// Usage
const db = createDatabaseConnection({
    host: 'localhost',
    port: 5432,
    database: 'myapp',
    maxConnections: 10
});

db.connect('client-1');
db.connect('client-2');
console.log(db.getStatus());

db.disconnect('client-1');
console.log(db.getStatus());

Currying

Currying transforms a function with multiple arguments into a sequence of functions each taking a single argument.

Basic Currying

// Regular function
function add(a: number, b: number): number {
    return a + b;
}

console.log(add(2, 3));  // 5

// Curried version
function addCurried(a: number): (b: number) => number {
    return (b: number) => a + b;
}

const add2 = addCurried(2);
console.log(add2(3));  // 5
console.log(add2(5));  // 7

// Or directly
console.log(addCurried(2)(3));  // 5

Currying with Arrow Functions

const multiply = (a: number) => (b: number) => a * b;

const double = multiply(2);
const triple = multiply(3);

console.log(double(5));  // 10
console.log(triple(5));  // 15

// Three arguments
const calculateTotal = (price: number) => (quantity: number) => (taxRate: number) =>
    price * quantity * (1 + taxRate);

const laptopPrice = calculateTotal(1200);
const twoLaptops = laptopPrice(2);
const withTax = twoLaptops(0.1);

console.log(withTax);  // 2640

// Or all at once
console.log(calculateTotal(1200)(2)(0.1));  // 2640

Partial Application

Partial application fixes some arguments, creating a new function.

// Partial application helper
function partial<A, B, C>(
    fn: (a: A, b: B) => C,
    a: A
): (b: B) => C {
    return (b: B) => fn(a, b);
}

// Regular function
function greet(greeting: string, name: string): string {
    return `${greeting}, ${name}!`;
}

// Create specialized functions
const sayHello = partial(greet, 'Hello');
const sayGoodbye = partial(greet, 'Goodbye');

console.log(sayHello('Alice'));    // "Hello, Alice!"
console.log(sayGoodbye('Bob'));    // "Goodbye, Bob!"

Real Example: Validation Functions

interface ValidationRule<T> {
    (value: T): boolean;
}

// Curried validation builders
const minLength = (min: number) => (value: string): boolean =>
    value.length >= min;

const maxLength = (max: number) => (value: string): boolean =>
    value.length <= max;

const matches = (pattern: RegExp) => (value: string): boolean =>
    pattern.test(value);

const isInRange = (min: number, max: number) => (value: number): boolean =>
    value >= min && value <= max;

// Create specific validators
const isValidUsername = (username: string): boolean => {
    const validators = [
        minLength(3),
        maxLength(20),
        matches(/^[a-zA-Z0-9_]+$/)
    ];
    
    return validators.every(validate => validate(username));
};

const isValidAge = (age: number): boolean => {
    const validators = [
        isInRange(0, 150)
    ];
    
    return validators.every(validate => validate(age));
};

const isValidEmail = matches(/^[^\s@]+@[^\s@]+\.[^\s@]+$/);

// Usage
console.log(isValidUsername('alice'));      // true
console.log(isValidUsername('a'));          // false - too short
console.log(isValidUsername('alice@123'));  // false - invalid chars

console.log(isValidAge(25));   // true
console.log(isValidAge(200));  // false

console.log(isValidEmail('[email protected]'));  // true
console.log(isValidEmail('invalid'));            // false

Real Example: Authorization Middleware

interface User {
    id: string;
    username: string;
    roles: string[];
    permissions: string[];
}

interface Request {
    user?: User;
    path: string;
    method: string;
}

type AuthMiddleware = (req: Request) => boolean;

// Curried authorization builders
const requireRole = (role: string) => (req: Request): boolean => {
    return req.user?.roles.includes(role) ?? false;
};

const requirePermission = (permission: string) => (req: Request): boolean => {
    return req.user?.permissions.includes(permission) ?? false;
};

const requireAnyRole = (...roles: string[]) => (req: Request): boolean => {
    return roles.some(role => req.user?.roles.includes(role) ?? false);
};

const requireAllRoles = (...roles: string[]) => (req: Request): boolean => {
    return roles.every(role => req.user?.roles.includes(role) ?? false);
};

const requireAuthenticated = (req: Request): boolean => {
    return req.user !== undefined;
};

// Combine middleware
const combineAuth = (...middleware: AuthMiddleware[]): AuthMiddleware =>
    (req: Request) => middleware.every(mw => mw(req));

// Create specific authorization checks
const requireAdmin = requireRole('admin');
const requireEditor = requireRole('editor');
const requireWrite = requirePermission('write');

const requireAdminOrEditor = requireAnyRole('admin', 'editor');
const requireAuthenticatedEditor = combineAuth(
    requireAuthenticated,
    requireEditor
);

// Usage
const adminUser: User = {
    id: '1',
    username: 'admin',
    roles: ['admin', 'editor'],
    permissions: ['read', 'write', 'delete']
};

const editorUser: User = {
    id: '2',
    username: 'editor',
    roles: ['editor'],
    permissions: ['read', 'write']
};

const request: Request = {
    user: adminUser,
    path: '/api/users',
    method: 'DELETE'
};

console.log(requireAdmin(request));              // true
console.log(requireEditor(request));             // true
console.log(requireWrite(request));              // true
console.log(requireAdminOrEditor(request));      // true
console.log(requireAuthenticatedEditor(request)); // true

const editorRequest: Request = {
    user: editorUser,
    path: '/api/posts',
    method: 'POST'
};

console.log(requireAdmin(editorRequest));        // false
console.log(requireEditor(editorRequest));       // true
console.log(requireWrite(editorRequest));        // true

Real Example: Logger Factory

type LogLevel = 'debug' | 'info' | 'warn' | 'error';

interface LogConfig {
    level: LogLevel;
    prefix?: string;
    timestamp?: boolean;
}

function createLogger(config: LogConfig) {
    const levels: Record<LogLevel, number> = {
        debug: 0,
        info: 1,
        warn: 2,
        error: 3
    };
    
    const currentLevel = levels[config.level];
    
    const formatMessage = (level: LogLevel, message: string): string => {
        const parts: string[] = [];
        
        if (config.timestamp) {
            parts.push(new Date().toISOString());
        }
        
        if (config.prefix) {
            parts.push(`[${config.prefix}]`);
        }
        
        parts.push(`[${level.toUpperCase()}]`);
        parts.push(message);
        
        return parts.join(' ');
    };
    
    const log = (level: LogLevel) => (message: string) => {
        if (levels[level] >= currentLevel) {
            console.log(formatMessage(level, message));
        }
    };
    
    return {
        debug: log('debug'),
        info: log('info'),
        warn: log('warn'),
        error: log('error')
    };
}

// Create different loggers
const appLogger = createLogger({
    level: 'info',
    prefix: 'APP',
    timestamp: true
});

const dbLogger = createLogger({
    level: 'debug',
    prefix: 'DB',
    timestamp: true
});

const prodLogger = createLogger({
    level: 'warn',
    prefix: 'PROD',
    timestamp: true
});

// Usage
appLogger.debug('This won't show');     // level is 'info'
appLogger.info('App started');          // Shows
appLogger.warn('Low memory');           // Shows
appLogger.error('Connection failed');   // Shows

dbLogger.debug('Query executed');       // Shows - level is 'debug'
dbLogger.info('Connection pool ready'); // Shows

prodLogger.info('This won't show');     // level is 'warn'
prodLogger.warn('Rate limit exceeded'); // Shows
prodLogger.error('Service down');       // Shows

Real Example: Query Builder

interface QueryConfig {
    table: string;
    where?: Record<string, any>;
    limit?: number;
    offset?: number;
    orderBy?: { column: string; direction: 'ASC' | 'DESC' };
}

function createQueryBuilder(table: string) {
    let config: QueryConfig = { table };
    
    const builder = {
        where: (conditions: Record<string, any>) => {
            config = { ...config, where: { ...config.where, ...conditions } };
            return builder;
        },
        
        limit: (count: number) => {
            config = { ...config, limit: count };
            return builder;
        },
        
        offset: (count: number) => {
            config = { ...config, offset: count };
            return builder;
        },
        
        orderBy: (column: string, direction: 'ASC' | 'DESC' = 'ASC') => {
            config = { ...config, orderBy: { column, direction } };
            return builder;
        },
        
        build: (): string => {
            let query = `SELECT * FROM ${config.table}`;
            
            if (config.where) {
                const conditions = Object.entries(config.where)
                    .map(([key, value]) => `${key} = '${value}'`)
                    .join(' AND ');
                query += ` WHERE ${conditions}`;
            }
            
            if (config.orderBy) {
                query += ` ORDER BY ${config.orderBy.column} ${config.orderBy.direction}`;
            }
            
            if (config.limit) {
                query += ` LIMIT ${config.limit}`;
            }
            
            if (config.offset) {
                query += ` OFFSET ${config.offset}`;
            }
            
            return query;
        }
    };
    
    return builder;
}

// Usage - fluent API
const query = createQueryBuilder('users')
    .where({ status: 'active' })
    .where({ role: 'admin' })
    .orderBy('created_at', 'DESC')
    .limit(10)
    .build();

console.log(query);
// "SELECT * FROM users WHERE status = 'active' AND role = 'admin' ORDER BY created_at DESC LIMIT 10"

// Different queries from same builder
const activeUsers = createQueryBuilder('users')
    .where({ status: 'active' })
    .build();

const recentAdmins = createQueryBuilder('users')
    .where({ role: 'admin' })
    .orderBy('last_login', 'DESC')
    .limit(5)
    .build();

Currying Utility

// Generic curry function
function curry<A, B, C>(fn: (a: A, b: B) => C): (a: A) => (b: B) => C {
    return (a: A) => (b: B) => fn(a, b);
}

function curry3<A, B, C, D>(
    fn: (a: A, b: B, c: C) => D
): (a: A) => (b: B) => (c: C) => D {
    return (a: A) => (b: B) => (c: C) => fn(a, b, c);
}

// Regular functions
function add(a: number, b: number): number {
    return a + b;
}

function multiply(a: number, b: number, c: number): number {
    return a * b * c;
}

// Curry them
const curriedAdd = curry(add);
const curriedMultiply = curry3(multiply);

// Use curried versions
const add5 = curriedAdd(5);
console.log(add5(10));  // 15

const multiplyBy2 = curriedMultiply(2);
const multiplyBy2And3 = multiplyBy2(3);
console.log(multiplyBy2And3(4));  // 24

Real Example: API Client Builder

interface RequestConfig {
    method: string;
    headers: Record<string, string>;
    baseUrl: string;
}

function createApiClient(baseUrl: string) {
    const defaultHeaders = {
        'Content-Type': 'application/json'
    };
    
    const request = (method: string) => (path: string) => async (body?: any) => {
        const url = `${baseUrl}${path}`;
        const headers = { ...defaultHeaders };
        
        const options: RequestInit = {
            method,
            headers
        };
        
        if (body) {
            options.body = JSON.stringify(body);
        }
        
        console.log(`${method} ${url}`);
        // const response = await fetch(url, options);
        // return await response.json();
        
        return { success: true, data: body };
    };
    
    return {
        get: request('GET'),
        post: request('POST'),
        put: request('PUT'),
        delete: request('DELETE')
    };
}

// Create API client
const api = createApiClient('https://api.example.com');

// Usage - curried approach
const getUser = api.get('/users/:id');
const createUser = api.post('/users');
const updateUser = api.put('/users/:id');
const deleteUser = api.delete('/users/:id');

// Use the functions
(async () => {
    await getUser();
    await createUser({ username: 'alice', email: '[email protected]' });
    await updateUser({ username: 'alice_updated' });
    await deleteUser();
})();

Memoization with Closures

function memoize<T extends (...args: any[]) => any>(fn: T): T {
    const cache = new Map<string, ReturnType<T>>();
    
    return ((...args: Parameters<T>) => {
        const key = JSON.stringify(args);
        
        if (cache.has(key)) {
            console.log('Cache hit for', args);
            return cache.get(key);
        }
        
        console.log('Computing for', args);
        const result = fn(...args);
        cache.set(key, result);
        return result;
    }) as T;
}

// Expensive function
function fibonacci(n: number): number {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// Memoized version
const fastFib = memoize(fibonacci);

console.log(fastFib(10));  // Computing...
console.log(fastFib(10));  // Cache hit!
console.log(fastFib(15));  // Computing...

Best Practices

1. Use Closures for Private State

// Good - private state
function createAccount(initialBalance: number) {
    let balance = initialBalance;  // Private
    
    return {
        deposit: (amount: number) => {
            balance += amount;
            return balance;
        },
        getBalance: () => balance
    };
}

// Bad - exposed state
class Account {
    balance: number;  // Public - can be modified directly
    
    constructor(initialBalance: number) {
        this.balance = initialBalance;
    }
}

2. Curry for Reusability

// Curried for flexibility
const hasRole = (role: string) => (user: User) => user.roles.includes(role);

const isAdmin = hasRole('admin');
const isEditor = hasRole('editor');

const admins = users.filter(isAdmin);
const editors = users.filter(isEditor);

3. Partial Application for Configuration

// Configure once, use many times
const logWithPrefix = (prefix: string) => (message: string) =>
    console.log(`[${prefix}] ${message}`);

const logError = logWithPrefix('ERROR');
const logInfo = logWithPrefix('INFO');

logError('Connection failed');
logInfo('Server started');

What's Next

You now understand:

• Closures and lexical scope

• Currying for flexible functions

• Partial application

• Function factories

• Encapsulation with closures

• Configuration through closures

In Part 4: Functional Error Handling, you'll learn to handle errors functionally using Either/Result types, Option/Maybe patterns, Railway-oriented programming, and composing error-handling logic.

---

Based on building production TypeScript systems with authentication, logging, validation, and API clients using closures and currying.