Course contentsShow
← JavaScript
Lesson 1783 of 2,72337. Functional Programming PatternsFree lesson

Debugging Composed Functions

Learn techniques to inspect intermediate values in a composition pipeline, including tap functions and logging.

Debugging Composed Functions

You'll learn how to inspect intermediate values inside a composition pipeline without breaking the flow.

The Challenge with Composition

When you compose functions together—whether with compose() or pipe()—the data flows invisibly from one function to the next. If something goes wrong or produces unexpected output, it's hard to see what's happening at each step. Unlike debugging sequential code where you can insert console.log() statements, composition chains don't have obvious places to pause and inspect.

The Tap Function Technique

The solution is a tap function: a utility that lets you "peek" at a value without modifying it. Think of it like a glass window in a pipe—you can see what's flowing through without interrupting the flow.

const tap = (fn) => (value) => {
  fn(value);
  return value; // Always return the original value unchanged
};

// Example: debugging a pipeline
const processData = pipe(
  trimSpaces,
  tap(x => console.log('After trim:', x)),
  toLowerCase,
  tap(x => console.log('After lowercase:', x)),
  removeVowels
);

processData('  HELLO  ');
// Logs: "After trim: HELLO"
// Logs: "After lowercase: hello"
// Returns: "hll"

Why Tap Works

The tap function takes a side-effect function (like console.log) but always returns the original value. This preserves the composition chain while giving you visibility into each transformation step. It's particularly useful for logging, validation checks, or triggering breakpoints during development.

You can also create specialized taps:

const logTap = tap(console.log);
const debugTap = tap(x => debugger); // Pauses execution at that point

Key Takeaway: Use tap functions to insert logging or debugging checkpoints into composition pipelines without breaking the data flow—inspect values transparently while keeping functions pure.