Operador Tap

`&.` ejecuta un efecto secundario y devuelve el valor original — el "espía" del pipeline.

El operador &. llama a f(valor) pero descarta el retorno y propaga el valor original al siguiente paso. Es el punto adecuado para logs, métricas y depuración en medio de un pipeline sin interrumpir el flujo.

La forma más común combina |> con &. en el mismo paso: el pipe avanza la transformación, el tap solo observa:

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

02-tap-side-effects.zolo

Playground

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

Gotcha: al usar tap en arrays dentro de un pipeline de |>, prefiere extraer la etapa intermedia en una variable y llamar print(arr) directamente. Interpolar un array dentro de una cadena ("{arr}") muestra el handle interno, no los elementos.

Encuentra tu camino por Zolo

Empieza aquí