JavaScript Currying — Why fn.length Lies With Defaults

// ─── 1. A normal multi-argument function ───────────────────────────────────
function calculateTax(taxRate, price) {
  return price * (1 + taxRate);
}

console.log(calculateTax(0.2, 100)); // 120 — works, but we repeat 0.2 everywhere

// ─── 2. Hand-written curried version ───────────────────────────────────────
// taxRate is captured in the closure returned by applyTax.
// The inner function is created fresh each time applyTax() is called.
function applyTax(taxRate) {
  // This returned function closes over 'taxRate'.
  // JavaScript keeps taxRate alive in the closure scope
  // as long as this returned function is reachable.
  return function chargePrice(price) {
    return price * (1 + taxRate);
  };
}

// Lock in the UK VAT rate ONCE at module load time.
const applyUKVAT = applyTax(0.20); // returns chargePrice with taxRate = 0.20
const applyUSStateTax = applyTax(0.085); // returns chargePrice with taxRate = 0.085

console.log(applyUKVAT(100));   // 120   — price injected later
console.log(applyUKVAT(250));   // 300
console.log(applyUSStateTax(100)); // 108.5

// ─── 3. Proving the closure is truly isolated ───────────────────────────────
// Each call to applyTax() produces a SEPARATE closure scope.
// Changing one does not affect the other.
console.log(applyUKVAT === applyUSStateTax); // false — different function objects
console.log(applyUKVAT(100) === applyUSStateTax(100)); // false — different results

// ─── Generic curry() — handles any arity, accepts partial batches ──────────
function curry(originalFn) {
  // fn.length = number of DECLARED parameters (excludes rest params & defaults)
  const expectedArgCount = originalFn.length;

  // The recursive accumulator. 'collectedArgs' grows with each partial call.
  function accumulate(...collectedArgs) {
    if (collectedArgs.length >= expectedArgCount) {
      // We have everything the original function needs — fire it.
      return originalFn(...collectedArgs);
    }

    // Not enough args yet. Return a NEW function that remembers what we have.
    return function(...newArgs) {
      // Spread both arrays: previously collected + freshly received.
      return accumulate(...collectedArgs, ...newArgs);
    };
  }

  return accumulate;
}

// ─── Real-world example: building a discount pricing pipeline ───────────────
function applyDiscount(discountPercent, taxRate, basePrice) {
  const discounted = basePrice * (1 - discountPercent / 100);
  return discounted * (1 + taxRate);
}

const curriedPricing = curry(applyDiscount);

// Strategy 1: one argument at a time (classic currying)
const withBlackFridayDiscount = curriedPricing(30);      // discount locked in
const withVAT = withBlackFridayDiscount(0.20);            // tax rate locked in
console.log(withVAT(100));   // 84  — (100 * 0.70) * 1.20
console.log(withVAT(200));   // 168

// Strategy 2: partial batch (two args at once, one later)
const blackFridayUKPricing = curriedPricing(30, 0.20);   // two at once
console.log(blackFridayUKPricing(100)); // 84
console.log(blackFridayUKPricing(50));  // 42

// Strategy 3: all at once — just calls the original function immediately
console.log(curriedPricing(30, 0.20, 100)); // 84

// ─── Inspecting fn.length vs rest params ───────────────────────────────────
function regularFn(a, b, c) { return a + b + c; }
function withDefault(a, b = 10, c) { return a + b + c; }   // b has a default
function withRest(a, ...rest) { return a; }                  // rest param

console.log(regularFn.length);   // 3
console.log(withDefault.length); // 1  ← only params BEFORE the first default
console.log(withRest.length);    // 1  ← rest params don't count

// ─── Partial Application with bind() ────────────────────────────────────────
function sendEmail(smtpServer, fromAddress, toAddress, subject, body) {
  return `[${smtpServer}] FROM: ${fromAddress} TO: ${toAddress} | ${subject}: ${body}`;
}

// bind() fixes 'this' (null here) and the first two arguments.
// The result still accepts THREE arguments at once — not curried.
const sendFromSupport = sendEmail.bind(
  null,
  'smtp.myapp.com',
  'support@myapp.com'
);

// sendFromSupport takes toAddress, subject, body all at once
console.log(
  sendFromSupport('user@gmail.com', 'Your order', 'It has shipped!')
);

// ─── True (unary) Currying — one argument per call ──────────────────────────
function curryStrict(fn) {
  // Forces exactly ONE argument per step, regardless of fn.length
  return function step(arg) {
    // If the original function only needs one arg, call it now.
    if (fn.length <= 1) return fn(arg);
    // Otherwise partially apply this single arg and curry what's left.
    return curryStrict(fn.bind(null, arg));
  };
}

const strictlyCurriedEmail = curryStrict(sendEmail);

// Must be called one argument at a time — passing two would only use the first
const step1 = strictlyCurriedEmail('smtp.myapp.com');
const step2 = step1('support@myapp.com');
const step3 = step2('user@gmail.com');
const step4 = step3('Your order');
const result = step4('It has shipped!');
console.log(result);

// ─── Comparison: what each approach returns ──────────────────────────────────
console.log('bind result arity:', sendFromSupport.length);      // 3 (toAddress, subject, body)
console.log('strict curry arity:', strictlyCurriedEmail.length); // 1 (always unary)

// ─── Utility: pipe (left-to-right composition) ──────────────────────────────
// pipe(f, g, h)(value) === h(g(f(value)))
const pipe = (...fns) => (initialValue) =>
  fns.reduce((currentValue, fn) => fn(currentValue), initialValue);

// ─── Curried data-transformation helpers ────────────────────────────────────
const filterBy = (predicate) => (collection) =>
  collection.filter(predicate);

const mapWith = (transform) => (collection) =>
  collection.map(transform);

const sortByField = (field) => (collection) =>
  [...collection].sort((a, b) => (a[field] > b[field] ? 1 : -1)); // non-mutating sort

const take = (count) => (collection) =>
  collection.slice(0, count);

// ─── Real dataset: e-commerce orders ────────────────────────────────────────
const orders = [
  { id: 'ORD-001', product: 'Keyboard', amount: 79.99, status: 'shipped' },
  { id: 'ORD-002', product: 'Monitor',  amount: 399.99, status: 'pending' },
  { id: 'ORD-003', product: 'Mouse',    amount: 29.99, status: 'shipped' },
  { id: 'ORD-004', product: 'Webcam',   amount: 89.99, status: 'shipped' },
  { id: 'ORD-005', product: 'Headset',  amount: 149.99, status: 'pending' },
];

// ─── Build a reusable pipeline with point-free style ─────────────────────────
// Goal: get the top 2 shipped orders by amount, formatted for a receipt

const formatForReceipt = (order) => ({
  reference: order.id,
  description: order.product,
  total: `$${order.amount.toFixed(2)}`,
});

const getTopShippedOrders = pipe(
  filterBy((order) => order.status === 'shipped'),   // only shipped
  sortByField('amount'),                              // ascending by price
  (sorted) => sorted.reverse(),                      // descending (highest first)
  take(2),                                            // top 2
  mapWith(formatForReceipt)                           // shape for receipt
);

const receiptLines = getTopShippedOrders(orders);
console.log(receiptLines);

// ─── The power: swap one piece without touching the rest ─────────────────────
const getPendingOrderSummary = pipe(
  filterBy((order) => order.status === 'pending'), // just change this line
  sortByField('amount'),
  mapWith(formatForReceipt)
);

console.log(getPendingOrderSummary(orders));

// ─── Bad: creating curried functions inside render (React) ───────────────
function BadComponent() {
  // New closure every render — breaks React.memo
  const handleClick = (id) => (event) => {
    console.log(id, event);
  };

  return <button onClick={handleClick(5)}>Click</button>;
}

// ─── Good: curried function created once outside component ─────────────────
const createHandler = (id) => (event) => {
  console.log(id, event);
};

function GoodComponent() {
  // createHandler is stable — no re-creation
  const handleClick = useCallback(() => createHandler(5), []);
  return <button onClick={handleClick}>Click</button>;
}

// ─── Monitoring closure allocations in Node.js ───────────────────────────────
const heapStats = () => {
  const used = process.memoryUsage().heapUsed;
  console.log(`Heap used: ${(used / 1024 / 1024).toFixed(2)} MB`);
};

// Currying in a hot loop — watch heap grow
const add = curry((a, b, c) => a + b + c);
for (let i = 0; i < 100000; i++) {
  const add5 = add(5);   // closure allocation
  const add5and10 = add5(10);  // another closure
  add5and10(15);
}
heapStats(); // Expect heap to be higher due to retained closures? Actually V8 may GC between iterations

// ─── Pre-allocate partial applications for speed ─────────────────────────────
const add5Pre = add(5);  // allocate once
for (let i = 0; i < 100000; i++) {
  const add5and10 = add5Pre(10);  // still allocates, but less overhead
  add5and10(15);
}
heapStats();

// io.thecodeforge
function logger(date) {
  return function(severity) {
    return function(message) {
      const timestamp = date.toISOString();
      console.log(`[${timestamp}] [${severity.toUpperCase()}] ${message}`);
    };
  };
}

// One-time setup at app boot
const logNow = logger(new Date());
const logNowInfo = logNow('info');

// Every handler just calls the pre-baked version
logNowInfo('User session started');
logNowInfo('Payment processed');

// io.thecodeforge
// Pitfall: variadic function with arrow curry
const logVariadic = (...args) => console.log(...args);
console.log(logVariadic.length); // 0 — breaks arity detection

// Safe approach: fixed-arity arrow curry
const safeLog = date => severity => message => {
  console.log(`[${date.toISOString()}] [${severity}] ${message}`);
};

// Production fix: explicit function wraps the variadic
function curryVariadic(fn) {
  return function curried(...args) {
    // Custom logic for rest parameters
    if (args.length >= 1) return fn(...args);
    return (...more) => curried(...args, ...more);
  };
}