map / select / reduce, ou penser en transformations map / select / reduce, or thinking in transformations

Décrire une transformation, au lieu de piloter une boucle.Describe a transformation, instead of driving a loop.

La fondation posée (un each débloque tout), voici le style qu'elle permet. Une boucle impérative dit comment : crée un accumulateur, parcours, teste, pousse, additionne. Une chaîne de transformations dit quoi : garde les payées, applique la TVA, fais la somme. Trois verbes couvrent l'essentiel — map transforme chaque élément (1 pour 1), select filtre (garde ou jette), reduce replie une collection en une seule valeur. Les chaîner, c'est écrire un pipeline qui se lit de gauche à droite comme une phrase, où chaque étape nomme son intention au lieu de la cacher dans la mécanique d'une boucle.With the foundation laid (one each unlocks everything), here's the style it enables. An imperative loop says how: create an accumulator, traverse, test, push, add. A chain of transformations says what: keep the paid ones, apply the tax, sum. Three verbs cover the essentials — map transforms each element (1 for 1), select filters (keep or drop), reduce folds a collection into a single value. Chaining them writes a pipeline that reads left to right like a sentence, where each step names its intent instead of hiding it in a loop's machinery.

# impératif : on accumule à la main, l'intention se devine
totals = []
orders.each do |o|
  next unless o.paid?
  totals << o.amount * 1.2
end
sum = 0
totals.each { |t| sum += t }

# déclaratif : on DÉCRIT la transformation, l'intention se lit
sum = orders.select(&:paid?)        # garder les payées
            .map { |o| o.amount * 1.2 }  # appliquer la TVA
            .sum                    # replier en un total

La boucle cache l'intention dans un accumulateur ; la chaîne la montre.The loop hides the intent in an accumulator; the chain shows it.

Mets les deux versions côte à côte et la différence saute aux yeux. La boucle impérative entrelace trois choses dans un seul bloc : le filtre (next unless), l'initialisation de l'accumulateur (||= 0) et le repli (+=). Pour la comprendre, on doit la dérouler mentalement, tour par tour, et reconstituer ce qu'elle calcule. La chaîne sépare ces préoccupations en étapes nommées, lues de haut en bas : garder, regrouper, sommer. On ne simule plus l'exécution ; on lit une description. C'est ça, penser en transformations : décrire le quoi, et laisser chaque méthode porter le comment.Put the two versions side by side and the difference is obvious. The imperative loop interleaves three things in one block: the filter (next unless), the accumulator init (||= 0) and the fold (+=). To understand it, you must unroll it mentally, turn by turn, and reconstruct what it computes. The chain separates these concerns into named steps, read top to bottom: keep, group, sum. You no longer simulate execution; you read a description. That's thinking in transformations: describe the what, and let each method carry the how.

# l'intention est noyée dans la mécanique d'accumulation
def report(orders)
  by_country = {}
  orders.each do |o|
    next unless o.paid?              # le filtre, perdu au milieu
    by_country[o.country] ||= 0      # l'init manuelle de l'accumulateur
    by_country[o.country] += o.total # le repli, à la main
  end
  by_country
end
# pour comprendre : il faut SIMULER la boucle dans sa tête, tour par tour

Rien n'est faux ici — mais tout est mêlé. Le next unless, le ||= 0, le += vivent dans le même bloc, et l'intention (« total payé par pays ») n'apparaît nulle part en clair : il faut la déduire de la mécanique. Ajouter un critère, c'est rouvrir et relire toute la boucle.Nothing is wrong here — but everything is mixed. The next unless, the ||= 0, the += live in one block, and the intent ("paid total per country") appears nowhere plainly: you deduce it from the machinery. Adding a criterion means reopening and rereading the whole loop.

Au-delà du trio : each_with_object, flat_map, tap, then.Beyond the trio: each_with_object, flat_map, tap, then.

map, select, reduce couvrent l'essentiel, mais quelques voisins rendent les chaînes plus nettes. flat_map fait map puis aplatit d'un niveau ; filter_map combine select et map en une passe. Pour construire une collection, each_with_object bat souvent inject : il rend l'objet automatiquement, là où inject t'oblige à renvoyer l'accumulateur à chaque tour (l'oublier est un bug classique). Et deux outils de chaînage pur : tap espionne une valeur sans rompre la chaîne (il renvoie self), then (alias yield_self) passe une valeur à un bloc et renvoie son résultat — un pipe pour brancher une étape qui n'est pas une méthode de la collection.map, select, reduce cover the essentials, but a few neighbors make chains cleaner. flat_map does map then flattens one level; filter_map combines select and map in one pass. To build a collection, each_with_object often beats inject: it returns the object automatically, where inject forces you to return the accumulator each turn (forgetting it is a classic bug). And two pure-chaining tools: tap spies a value without breaking the chain (it returns self), then (alias yield_self) passes a value to a block and returns its result — a pipe to plug in a step that isn't a collection method.

[1, 2, 3].map { |x| x * 2 }            # => [2, 4, 6]  1 pour 1
[1, 2, 3, 4].select(&:even?)          # => [2, 4]     filtre
[1, 2, 3, 4].reduce(0) { |a, x| a + x } # => 10       replie (ou .sum)

# flat_map : map + aplatit d'un niveau (évite un .map.flatten)
[[1, 2], [3, 4]].flat_map { |pair| pair }   # => [1, 2, 3, 4]

# filter_map : select + map en une passe (évite un .map.compact)
[1, 2, 3, 4].filter_map { |x| x * 10 if x.even? }   # => [20, 40]

# each_with_object : construire une collection SANS threader le retour
words.each_with_object(Hash.new(0)) { |w, counts| counts[w] += 1 }
# l'objet (counts) est rendu automatiquement — pas de « ; counts » final

# inject/reduce fait pareil, mais TU dois renvoyer l'accumulateur :
words.inject(Hash.new(0)) { |counts, w| counts[w] += 1; counts }
#                                                          ^^^^^ oublié = bug

# tap : espionne sans casser la chaîne (renvoie self)
build_query.tap { |q| log(q) }.execute

# then (yield_self) : passe self à un bloc et renvoie son résultat
total.then { |t| Money.new(t) }

Le repère de choix : map quand le résultat fait 1 pour 1, select/reject pour filtrer, reduce pour replier en une valeur, each_with_object pour bâtir une collection. Et avant d'enchaîner deux étapes, regarde s'il existe une méthode unique qui le dit — flat_map, filter_map, sum, tally, partition — c'est le sujet du piège qui suit.The choosing cue: map when the result is 1 for 1, select/reject to filter, reduce to fold into one value, each_with_object to build a collection. And before chaining two steps, check whether a single method says it — flat_map, filter_map, sum, tally, partition — the subject of the trap that follows.

Chaîner pour chaîner : map pour un effet, ou un pipeline qu'un mot disait.Chaining for its own sake: map for an effect, or a pipeline one word said.

Une fois converti aux transformations, on sur-corrige : on enchaîne par réflexe, même là où c'est trompeur ou inutile. Deux formes. La première : map pour un effet de bord — on transforme pour envoyer des mails, en ignorant le tableau produit. map alloue ce tableau pour rien, et surtout il ment au lecteur : il annonce « je calcule de nouvelles valeurs » alors qu'on voulait juste « pour chacun, fais ». each dit l'intention exacte. La seconde : une chaîne ingénieuse — select.first, map.compact, group_by.transform_values — là où Ruby a une méthode unique : find, filter_map, tally. Le réflexe fonctionnel n'est pas « tout chaîner », c'est « nommer juste » : each pour l'effet, et la méthode dédiée plutôt qu'un pipeline malin.Once converted to transformations, you over-correct: you chain by reflex, even where it's misleading or pointless. Two forms. First: map for a side effect — you transform to send emails, ignoring the produced array. map allocates that array for nothing, and worse it lies to the reader: it announces 'I'm computing new values' when you just meant 'for each, do'. each states the exact intent. Second: a clever chain — select.first, map.compact, group_by.transform_values — where Ruby has a single method: find, filter_map, tally. The functional reflex isn't 'chain everything', it's 'name precisely': each for the effect, and the dedicated method over a clever pipeline.

# Piège A : map pour un EFFET DE BORD — le tableau de retour est jeté
users.map { |u| send_welcome_email(u) }   # on ignore la valeur produite
# map alloue un Array de retours inutile, et SIGNALE « transformation »
# au lecteur, qui cherche en vain ce qu'on en fait

# Piège B : une chaîne maligne là où UNE méthode existe
orders.select(&:paid?).first               # → orders.find(&:paid?)
list.map(&:to_i).compact                   # → list.filter_map { ... }
words.group_by(&:itself).transform_values(&:size)  # → words.tally

# A : each dit l'intention — itérer pour l'effet, rien à collecter
users.each { |u| send_welcome_email(u) }

# B : la méthode dédiée dit le quoi, en un mot
orders.find(&:paid?)         # le premier payé, et il s'arrête là
list.filter_map { |s| Integer(s, exception: false) }   # filtre + transforme
words.tally                  # => { "a" => 3, "b" => 1 }  comptage direct