Operador Tap

Tap entre etapas de pipe; tap standalone en un array — observa sin alterar el valor.

// 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