A pattern gaining traction with software engineering agents like Claude Code involves processing an agent request in a loop until a goal state is achieved. Its most popular form is the Ralph Wiggum Loop. Many have written about Ralph, so I won’t rehash implementations here. Instead, I want to highlight that this pattern is reduce-while: a loop that accumulates state with each step but can terminate early when a condition is met.
Think of reduce-while like a bank account that starts with a balance, processes transactions, and with each step needs the previous balance to compute the new one. But if a transaction would overdraft the account, you stop. Here is the same example expressed in Rust and Elixir:
Rust
use std::ops::ControlFlow;
let transactions = [50.0, -20.0, -200.0, 15.0];
let result = transactions.iter().try_fold(100.0, |balance, &tx| {
let new_balance = balance + tx;
if new_balance < 0.0 {
ControlFlow::Break(balance)
} else {
ControlFlow::Continue(new_balance)
}
});
// ControlFlow::Break(130.0) — stopped before overdraft
Elixir
transactions = [50.0, -20.0, -200.0, 15.0]
result = Enum.reduce_while(transactions, 100.0, fn tx, balance ->
new_balance = balance + tx
if new_balance < 0.0 do
{:halt, balance}
else
{:cont, new_balance}
end
end)
# 130.0 — stopped before overdraft
What’s striking is that reduce-while isn’t new, but rather a foundational pattern from functional programming that now powers cutting-edge agent loops. We haven’t replaced old ways with new ones but built on them!
What other classical patterns might be hiding in plain sight within agentic workflows?