Tap Operator

Tap between pipe stages; standalone tap on an array — observes without changing the value.

// Feature: Tap operator `&.`
// Syntax: `value &. f()` calls `f(value)` but RETURNS the original `value`.
// When to use: side effects (log, debug, metrics) in the middle of a
// pipeline without breaking the flow. It is the "spy" between `|>` pipes.

fn double(x: int) -> int {
  return x * 2
}

fn add_one(x: int) -> int {
  return x + 1
}

// Function used as tap — print is the effect, return is discarded.
fn log_step(x: int) -> int {
  print("  [tap] x = {x}")
  return x
}

// Pipeline with tap between steps — observes without changing.
let r = 5
  |> double() &. log_step()
  // 10
  // prints 10, propagates 10
  |> add_one() &. log_step()
  // 11
  // prints 11, propagates 11
  |> double()
// 22
print("final = {r}")

// expected:
//   [tap] x = 10
//   [tap] x = 11
//   final = 22

// Tap is useful to inspect array length in the middle of the pipeline.
fn show_len(arr: [int]) -> [int] {
  print("  [len] {arr.len()}")
  return arr
}

let nums = [1, 2, 3, 4, 5] &. show_len()
print(nums.len())
// expected:
//   [len] 5
//   5