In Ruby, what is the difference between `Kernel#tap` and `Kernel#then` in a method chain, and when would you use each?

## Two methods, one difference Both methods are defined in `Kernel`, so every ordinary object has them (only `BasicObject` instances lack them), and both **yield the receiver to a block**. They differ only in what they **return**: | | `tap` | `then` (alias `yield_self`) | |---|---|---| | Yields | the receiver | the receiver | | Returns | the receiver, always | the block's return value | | Block's value | ignored | becomes the new value in the chain | | Without a block | `LocalJumpError` (it yields unconditionally) | an `Enumerator` | | Typical use | side effects: log, assert, configure | transformation: pipe into a function, branch | In Ruby's own source, `tap` is essentially `yield(self)` followed by `self`, while `then` returns the value of `yield(self)`. ## `tap`: look without changing the flow `tap` "taps into" a chain to act on an intermediate value while passing the same object on: ```ruby clean = raw_title .strip .tap { |t| warn "after strip: #{t.inspect}" } .squeeze(" ") ``` - The chain's value after `tap` is exactly what it was before, so removing the `tap` line changes nothing else. - It is also the idiom for configuring and returning a new object in one expression: `Product.new.tap { |p| p.title = clean }` returns the product, not the String assigned. - Because the same object is yielded, a **mutating** call inside `tap` is visible downstream: `tap { |t| t.upcase! }` changes the String, while `tap { |t| t.upcase }` builds a copy and throws it away. ## `then`: pipe the value somewhere new `then` lets a chain continue through code that is **not** a method of the current object, or through a branch: ```ruby display = raw_title .strip .squeeze(" ") .then { |t| t.empty? ? "Untitled product" : t } .then { |t| truncate_title(t, 60) } ``` - `truncate_title` is a helper that takes the String as an argument; `then` fits it into the left-to-right flow instead of wrapping the whole chain in `truncate_title(...)`. - Each `then` replaces the value, so the next link works on whatever the block returned, including a different type. - `yield_self` is the same method under its older name. RuboCop's pending `Style/ObjectThen` cop enforces one spelling, `then` by default. ## Choosing between them 1. Ask what the next link should receive. The **same object**: `tap`. A **computed value**: `then`. 2. If the block's value matters and you used `tap`, the value is silently lost; if you used `then` for a side effect such as logging, the chain continues with the logger's return value, often `nil` or `true`. 3. Prefer a plain method call when one exists: `title.strip.then { |t| t.squeeze(" ") }` is just `title.strip.squeeze(" ")`. ## The blockless forms `then` without a block returns an `Enumerator` over the single receiver, which enables short-circuit tricks from the core docs such as `2.then.detect(&:odd?)`, returning `nil` when the condition fails. `tap` has no blockless form; calling it without a block raises `LocalJumpError` because its body always yields. Neither form is common in application code, but the difference shows up in interview follow-ups. ## Common misconceptions - "`tap` returns whatever the block returns." That is `then`. - "`tap` works on a copy." It yields the receiver itself, so mutations stick. - "`then` mutates the receiver." It only passes it to the block; any change depends on what the block does. ## How to answer in an interview Lead with the one-line contrast: both yield the receiver, `tap` returns the receiver, `then` returns the block's value. Give one example of each from the same pipeline, a logging `tap` and a fallback `then`, and then name the trap that shows you have used them: `tap { |t| t.upcase }` does nothing visible, while `tap { |t| t.upcase! }` changes the object because the block receives the receiver itself, not a copy.