Funciones Puras

Una función pura tiene dos propiedades: (1) determinista — la misma entrada siempre produce la misma salida, (2) sin efectos secundarios — no modifica nada fuera de su ámbito: sin globales, sin escrituras en base de datos, sin I/O, sin mutaciones de sus argumentos. Las funciones puras son triviales de testear (sin setup, sin mocks), seguras para paralelizar y fáciles de razonar de forma aislada.

discount = 0.10  // global state

function calculateTotal(price, qty):
    // depends on external variable — not deterministic
    return price * qty * (1 - discount)

discount = 0.20  // change this → function behaves differently

function calculateTotal(price, qty, discount):
    // same inputs → always same output
    return price * qty * (1 - discount)

// Testing is trivial:
assert calculateTotal(10.0, 3, 0.10) == 27.0
assert calculateTotal(10.0, 3, 0.20) == 24.0

Mutar un argumento es un efecto secundario oculto — el invocador no lo espera. Si una función recibe una lista y la modifica en su lugar, cada parte del código que comparte esa lista se ve afectada silenciosamente. Devuelve nuevos valores en lugar de mutar. Aísla el I/O (escrituras en BD, llamadas HTTP, logging) en los límites de tu sistema — mantén la lógica central pura.

function applyDiscount(items, discount):
    for each item in items:
        item.price = item.price * (1 - discount)  // mutates in-place!
    return items

cart = [{ name: "book", price: 20 }]
applyDiscount(cart, 0.1)
// cart is now mutated — caller doesn't know

function applyDiscount(items, discount):
    result = []
    for each item in items:
        newItem = copy(item)
        newItem.price = item.price * (1 - discount)
        append newItem to result
    return result

cart = [{ name: "book", price: 20 }]
discounted = applyDiscount(cart, 0.1)
// cart unchanged, discounted is a new list

No puedes eliminar todos los efectos secundarios — los programas deben leer entradas y producir salidas. El objetivo es empujarlos a los límites: capa de UI, handlers de API, métodos de repositorio. Mantén la capa de lógica de negocio pura. Núcleo puro + shell impuro delgado es la arquitectura que hace las bases de código testeables, legibles y mantenibles a largo plazo.

// ✗ Business logic entangled with I/O
function processOrder(orderId):
    order = db.find(orderId)           // I/O
    if order.total > 1000:
        order.discount = 0.05
    else:
        order.discount = 0
    order.final = order.total * (1 - order.discount)
    db.save(order)                      // I/O
    email.send(order.user, "Confirmed") // I/O
    return order.final

// ✓ Pure core — I/O isolated at the edges
function calculateDiscount(total):   // pure
    return 0.05 if total > 1000 else 0.0

function calculateFinal(total, discount):  // pure
    return total * (1 - discount)

function processOrder(orderId):   // impure shell — thin and obvious
    order    = db.find(orderId)                         // I/O
    discount = calculateDiscount(order.total)           // pure
    final    = calculateFinal(order.total, discount)    // pure
    db.saveFinal(orderId, final)                        // I/O
    email.send(order.user, "Confirmed")                 // I/O
    return final

Esta función lee un global, muta su argumento y tiene un efecto secundario oculto. Convierte todas las entradas en parámetros explícitos y devuelve un valor sin tocar nada más.