@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/grokkingfp/ruby/part-2.md

@@ -0,0 +1,938 @@
+# Part II: 関数型スタイルのプログラミング
+
+本章では、関数型プログラミングの核心となるテクニックを学びます。イミュータブルなデータ操作、高階関数、そして `flat_map` による複雑なデータ変換を習得します。
+
+---
+
+## 第3章: イミュータブルなデータ操作
+
+### 3.1 イミュータブルとは
+
+イミュータブル（不変）とは、一度作成されたデータが変更されないことを意味します。データを「変更」する代わりに、新しいデータを「作成」します。
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "ミュータブル（可変）" as mut {
+  card "list = ['A', 'B']" as m1
+  card "list << 'C'" as m2
+  card "list = ['A', 'B', 'C']" as m3
+  m1 --> m2 : 変更
+  m2 --> m3 : 同じ配列が変わる
+}
+
+rectangle "イミュータブル（不変）" as immut {
+  card "list1 = ['A', 'B']" as i1
+  card "list2 = list1 + ['C']" as i2
+  card "list1 = ['A', 'B']\nlist2 = ['A', 'B', 'C']" as i3
+  i1 --> i2 : 新規作成
+  i2 --> i3 : 両方が存在
+}
+
+@enduml
+```
+
+**ソースファイル**: `app/ruby/src/ch03_immutable_values.rb`
+
+### 3.2 Array の基本操作
+
+Ruby では `+` 演算子を使って新しい配列を作成します。
+
+#### appended - 要素の追加
+
+```ruby
+def self.appended(list, element)
+  list + [element]
+end
+
+apple_book = %w[Apple Book]
+apple_book_mango = appended(apple_book, 'Mango')
+
+# 元のリストは変わらない
+apple_book.size        # => 2
+apple_book_mango.size  # => 3
+apple_book_mango       # => ["Apple", "Book", "Mango"]
+```
+
+#### take / drop / slice - 配列の切り出し
+
+```ruby
+def self.first_two(list)
+  list.take(2)
+end
+
+def self.last_two(list)
+  list.last(2)
+end
+
+def self.slice(list, start_idx, end_idx)
+  list[start_idx...end_idx] || []
+end
+
+first_two(%w[a b c])  # => ["a", "b"]
+last_two(%w[a b c])   # => ["b", "c"]
+slice(%w[a b c d], 1, 3)  # => ["b", "c"]
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "slice(start, end)" {
+  card "['a', 'b', 'c', 'd']" as orig
+  card "[1...3]" as op
+  card "['b', 'c']" as result
+
+  orig --> op
+  op --> result
+}
+
+note bottom of result
+  インデックス 1 から 3 の手前まで
+  (end は含まない)
+end note
+
+@enduml
+```
+
+### 3.3 リストの変換例
+
+```ruby
+# 最初の2要素を末尾に移動
+def self.moved_first_two_to_end(list)
+  return list if list.size <= 2
+
+  first_two = list.take(2)
+  rest = list.drop(2)
+  rest + first_two
+end
+
+moved_first_two_to_end(%w[a b c])  # => ["c", "a", "b"]
+
+# 最後の要素の前に挿入
+def self.inserted_before_last(list, element)
+  return [element] if list.empty?
+
+  without_last = list[0...-1]
+  last_elem = list[-1..]
+  without_last + [element] + last_elem
+end
+
+inserted_before_last(%w[a b], 'c')  # => ["a", "c", "b"]
+```
+
+### 3.4 旅程の再計画
+
+旅行の計画変更をイミュータブルに行う例です。
+
+```ruby
+def self.replan(plan, new_city, before_city)
+  index = plan.index(before_city)
+  return plan if index.nil?
+
+  before = plan.take(index)
+  after = plan.drop(index)
+  before + [new_city] + after
+end
+
+plan_a = %w[Paris Berlin Kraków]
+plan_b = replan(plan_a, 'Vienna', 'Kraków')
+
+plan_b  # => ["Paris", "Berlin", "Vienna", "Kraków"]
+plan_a  # => ["Paris", "Berlin", "Kraków"]  # 元の計画は変わらない!
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "旅程の再計画" {
+  card "Plan A:\nParis → Berlin → Kraków" as planA
+  card "replan(plan_a, 'Vienna', 'Kraków')" as op
+  card "Plan B:\nParis → Berlin → Vienna → Kraków" as planB
+
+  planA --> op
+  op --> planB
+}
+
+note right of planA
+  Plan A は変更されない
+  (イミュータブル)
+end note
+
+@enduml
+```
+
+### 3.5 名前の省略
+
+```ruby
+def self.abbreviate(name)
+  separator_idx = name.index(' ')
+  return name if separator_idx.nil?
+
+  initial = name[0]
+  last_name = name[(separator_idx + 1)..]
+  "#{initial}. #{last_name}"
+end
+
+abbreviate('Alonzo Church')  # => "A. Church"
+abbreviate('A. Church')      # => "A. Church"
+```
+
+---
+
+## 第4章: 関数を値として扱う
+
+### 4.1 高階関数とは
+
+高階関数（Higher-Order Function）とは、以下のいずれかを満たす関数です:
+
+1. 関数を引数として受け取る
+2. 関数を戻り値として返す
+
+**ソースファイル**: `app/ruby/src/ch04_functions_as_values.rb`
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "高階関数" {
+  rectangle "関数を引数に取る" as arg {
+    card "sort_by { |x| ... }" as sortBy
+    card "map { |x| ... }" as map
+    card "select { |x| ... }" as filter
+  }
+
+  rectangle "関数を返す" as ret {
+    card "larger_than_fn(n)" as larger
+    card "divisible_by(n)" as divisible
+  }
+}
+
+@enduml
+```
+
+### 4.2 関数を引数として渡す
+
+#### sort_by - ソート基準を関数で指定
+
+```ruby
+def self.score(word)
+  word.gsub(/a/i, '').length
+end
+
+words = %w[rust java]
+sorted_words = words.sort_by { |w| score(w) }
+
+sorted_words  # => ["java", "rust"]
+# java: 2文字 (j, v), rust: 4文字 (r, u, s, t)
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "sort_by の動作" {
+  card "['rust', 'java']" as input
+  card "score('rust') = 4\nscore('java') = 2" as scores
+  card "['java', 'rust']" as output
+
+  input --> scores : score関数を適用
+  scores --> output : スコア順にソート
+}
+
+@enduml
+```
+
+#### map - 各要素を変換
+
+```ruby
+def self.lengths(strings)
+  strings.map(&:length)
+end
+
+lengths(%w[scala rust ada])  # => [5, 4, 3]
+
+def self.double_all(numbers)
+  numbers.map { |n| n * 2 }
+end
+
+double_all([5, 1, 2, 4, 0])  # => [10, 2, 4, 8, 0]
+```
+
+#### select / filter - 条件に合う要素を抽出
+
+```ruby
+def self.odds(numbers)
+  numbers.select(&:odd?)
+end
+
+odds([5, 1, 2, 4, 0])  # => [5, 1]
+
+def self.larger_than(numbers, n)
+  numbers.select { |i| i > n }
+end
+
+larger_than([5, 1, 2, 4, 0], 4)  # => [5]
+```
+
+#### reduce / fold - 畳み込み
+
+```ruby
+def self.sum(numbers)
+  numbers.reduce(0, :+)
+end
+
+sum([5, 1, 2, 4, 100])  # => 112
+
+def self.maximum(numbers)
+  return nil if numbers.empty?
+  numbers.reduce { |max, n| n > max ? n : max }
+end
+
+maximum([5, 1, 2, 4, 15])  # => 15
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "reduce の動作" {
+  card "初期値: 0" as init
+  card "0 + 5 = 5" as s1
+  card "5 + 1 = 6" as s2
+  card "6 + 2 = 8" as s3
+  card "8 + 4 = 12" as s4
+  card "12 + 100 = 112" as s5
+
+  init --> s1
+  s1 --> s2
+  s2 --> s3
+  s3 --> s4
+  s4 --> s5
+}
+
+@enduml
+```
+
+### 4.3 Struct（case class 相当）
+
+```ruby
+# Struct を使った不変データ型
+ProgrammingLanguage = Struct.new(:name, :year, keyword_init: true) do
+  def young?(threshold_year)
+    year > threshold_year
+  end
+end
+
+java = ProgrammingLanguage.new(name: 'Java', year: 1995)
+scala = ProgrammingLanguage.new(name: 'Scala', year: 2004)
+
+languages = [java, scala]
+
+# フィールドにアクセス
+names = languages.map(&:name)
+names  # => ["Java", "Scala"]
+
+# 条件でフィルタ
+young = languages.select { |lang| lang.year > 2000 }
+young.map(&:name)  # => ["Scala"]
+```
+
+### 4.4 関数を返す関数
+
+```ruby
+def self.larger_than_fn(n)
+  ->(i) { i > n }
+end
+
+large = [5, 1, 2, 4, 0].select(&larger_than_fn(4))
+large  # => [5]
+
+medium = [5, 1, 2, 4, 0].select(&larger_than_fn(1))
+medium  # => [5, 2, 4]
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "関数を返す関数" {
+  card "larger_than_fn(4)" as call
+  card "->(i) { i > 4 }" as fn
+  card "select に渡す" as filter
+
+  call --> fn : Lambda を生成
+  fn --> filter : 生成された関数を使用
+}
+
+note bottom
+  larger_than_fn(4) は
+  「4より大きいか判定する Lambda」を返す
+end note
+
+@enduml
+```
+
+### 4.5 カリー化
+
+カリー化（Currying）は、複数の引数を取る関数を、引数を1つずつ取る関数のチェーンに変換する技法です。
+
+```ruby
+# カリー化された関数
+def self.larger_than_curried
+  ->(n) { ->(i) { i > n } }
+end
+
+# 使用例
+larger_than = larger_than_curried
+larger_than_5 = larger_than.call(5)
+larger_than_5.call(10)  # => true
+larger_than_5.call(3)   # => false
+
+# proc の curry メソッドも使える
+add = ->(a, b) { a + b }
+add_curried = add.curry
+add_5 = add_curried.call(5)
+add_5.call(3)  # => 8
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "カリー化" {
+  rectangle "通常の関数" as normal {
+    card "f(a, b, c)" as n1
+  }
+
+  rectangle "カリー化された関数" as curried {
+    card "f(a)(b)(c)" as c1
+  }
+
+  normal --> curried : カリー化
+}
+
+note bottom of curried
+  部分適用が可能
+  f(a) → 関数を返す
+  f(a)(b) → 関数を返す
+  f(a)(b)(c) → 結果を返す
+end note
+
+@enduml
+```
+
+### 4.6 ワードスコアリングの例
+
+複数のスコアリングロジックを組み合わせる例です。
+
+```ruby
+def self.score(word)
+  word.gsub(/a/i, '').length
+end
+
+def self.bonus(word)
+  word.downcase.include?('c') ? 5 : 0
+end
+
+def self.penalty(word)
+  word.downcase.include?('s') ? 7 : 0
+end
+
+words = %w[ada haskell scala java rust]
+
+# 関数を引数として渡す
+def self.ranked_words(words, &score_fn)
+  words.sort_by(&score_fn).reverse
+end
+
+# 基本スコアでランキング
+ranking1 = ranked_words(words) { |w| score(w) }
+ranking1  # => ["haskell", "rust", "scala", "java", "ada"]
+
+# ボーナス付きスコアでランキング
+ranking2 = ranked_words(words) { |w| score(w) + bonus(w) }
+ranking2.first  # => "scala"
+
+# ボーナスとペナルティ付きスコアでランキング
+ranking3 = ranked_words(words) { |w| score(w) + bonus(w) - penalty(w) }
+ranking3.first  # => "java"
+```
+
+### 4.7 関数合成
+
+```ruby
+# compose: f(g(x))
+def self.compose(f, g)
+  ->(x) { f.call(g.call(x)) }
+end
+
+# pipe: 左から右へ適用
+def self.pipe(value, *fns)
+  fns.reduce(value) { |acc, fn| fn.call(acc) }
+end
+
+add_one = ->(x) { x + 1 }
+double = ->(x) { x * 2 }
+
+composed = compose(add_one, double)
+composed.call(3)  # => 7  (double(3) = 6, add_one(6) = 7)
+
+pipe(3, add_one, double)  # => 8  (add_one(3) = 4, double(4) = 8)
+```
+
+---
+
+## 第5章: flat_map とネスト構造
+
+### 5.1 flatten と flat_map
+
+**ソースファイル**: `app/ruby/src/ch05_flatmap.rb`
+
+#### flatten - ネストした配列を平坦化
+
+```ruby
+Book = Struct.new(:title, :authors, keyword_init: true)
+
+books = [
+  Book.new(title: 'FP in Scala', authors: %w[Chiusano Bjarnason]),
+  Book.new(title: 'The Hobbit', authors: ['Tolkien'])
+]
+
+# map だけだとネストする
+author_lists = books.map(&:authors)
+# [["Chiusano", "Bjarnason"], ["Tolkien"]]
+
+# flatten で平坦化
+authors = author_lists.flatten
+# ["Chiusano", "Bjarnason", "Tolkien"]
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "flatten の動作" {
+  card "[['A', 'B'], ['C']]" as nested
+  card "flatten" as op
+  card "['A', 'B', 'C']" as flat
+
+  nested --> op
+  op --> flat
+}
+
+@enduml
+```
+
+#### flat_map = map + flatten
+
+```ruby
+# map して flatten
+authors1 = books.map(&:authors).flatten
+
+# flat_map で同じことを1行で
+authors2 = books.flat_map(&:authors)
+
+authors1 == authors2  # => true
+# ["Chiusano", "Bjarnason", "Tolkien"]
+```
+
+### 5.2 flat_map によるサイズの変化
+
+```ruby
+# 要素数が増える (1 -> 2)
+[1, 2, 3].flat_map { |i| [i, i + 10] }
+# => [1, 11, 2, 12, 3, 13]  - 6要素
+
+# 要素数が同じ (1 -> 1)
+[1, 2, 3].flat_map { |i| [i * 2] }
+# => [2, 4, 6]  - 3要素
+
+# 要素数が減る（フィルタリング効果）
+[1, 2, 3].flat_map { |i| i.even? ? [i] : [] }
+# => [2]  - 1要素
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "flat_map とサイズの変化" {
+  rectangle "増加" as inc {
+    card "[1, 2, 3]" as i1
+    card "{ |i| [i, i+10] }" as f1
+    card "[1, 11, 2, 12, 3, 13]" as r1
+    i1 --> f1
+    f1 --> r1
+  }
+
+  rectangle "減少（フィルタ）" as dec {
+    card "[1, 2, 3]" as i2
+    card "{ |i| i.even? ? [i] : [] }" as f2
+    card "[2]" as r2
+    i2 --> f2
+    f2 --> r2
+  }
+}
+
+@enduml
+```
+
+### 5.3 ネストした flat_map
+
+複数のリストを組み合わせる場合、flat_map をネストします。
+
+```ruby
+Book = Struct.new(:title, :authors, keyword_init: true)
+Movie = Struct.new(:title, keyword_init: true)
+
+def book_adaptations(author)
+  case author
+  when 'Tolkien'
+    [Movie.new(title: 'An Unexpected Journey'), Movie.new(title: 'The Desolation of Smaug')]
+  else
+    []
+  end
+end
+
+books = [
+  Book.new(title: 'FP in Scala', authors: %w[Chiusano Bjarnason]),
+  Book.new(title: 'The Hobbit', authors: ['Tolkien'])
+]
+
+# ネストした flat_map
+recommendations = books.flat_map do |book|
+  book.authors.flat_map do |author|
+    book_adaptations(author).map do |movie|
+      "You may like #{movie.title}, because you liked #{author}'s #{book.title}"
+    end
+  end
+end
+
+# 結果:
+# [
+#   "You may like An Unexpected Journey, because you liked Tolkien's The Hobbit",
+#   "You may like The Desolation of Smaug, because you liked Tolkien's The Hobbit"
+# ]
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "ネストした flat_map のフロー" {
+  card "books" as books
+  card "book.authors" as authors
+  card "book_adaptations(author)" as movies
+  card "recommendation string" as result
+
+  books --> authors : flat_map
+  authors --> movies : flat_map
+  movies --> result : map
+}
+
+note bottom
+  最後だけ map
+  途中は flat_map
+end note
+
+@enduml
+```
+
+### 5.4 デカルト積（全組み合わせ）
+
+```ruby
+def self.cartesian_product(list1, list2)
+  list1.flat_map do |a|
+    list2.map do |b|
+      [a, b]
+    end
+  end
+end
+
+cartesian_product([1, 2], %w[a b])
+# => [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
+
+# 3つのリストの組み合わせ
+def self.triplets(list1, list2, list3)
+  list1.flat_map do |a|
+    list2.flat_map do |b|
+      list3.map do |c|
+        [a, b, c]
+      end
+    end
+  end
+end
+```
+
+### 5.5 円内の点の判定
+
+```ruby
+Point = Struct.new(:x, :y, keyword_init: true) do
+  def distance_from_origin
+    Math.sqrt(x * x + y * y)
+  end
+end
+
+def inside?(point, radius)
+  point.x * point.x + point.y * point.y <= radius * radius
+end
+
+points = [Point.new(x: 5, y: 2), Point.new(x: 1, y: 1)]
+radiuses = [2, 1]
+
+# 全組み合わせを生成
+results = radiuses.flat_map do |r|
+  points.map do |point|
+    "Point(#{point.x}, #{point.y}) is within radius #{r}: #{inside?(point, r)}"
+  end
+end
+
+# フィルタリング（条件に合うもののみ）
+inside_points = radiuses.flat_map do |r|
+  points.flat_map do |point|
+    inside?(point, r) ? [{ point: point, radius: r }] : []
+  end
+end
+```
+
+### 5.6 モナディックパターンのプレビュー
+
+flat_map を使ったエラーハンドリングのパターンです（Part III で詳しく学びます）。
+
+```ruby
+# 安全な除算（結果を配列で返す）
+def self.safe_divide(a, b)
+  b.zero? ? [] : [a / b]
+end
+
+# 操作をチェーン
+def self.safe_calculation(a, b, c)
+  safe_divide(a, b).flat_map do |result1|
+    safe_divide(result1, c)
+  end
+end
+
+safe_calculation(100, 2, 5)  # => [10]
+safe_calculation(100, 0, 5)  # => []  (ゼロ除算は空配列)
+safe_calculation(100, 2, 0)  # => []
+
+# パースと計算の組み合わせ
+def self.safe_parse_int(str)
+  [Integer(str)]
+rescue ArgumentError
+  []
+end
+
+def self.parse_and_divide(str1, str2)
+  safe_parse_int(str1).flat_map do |a|
+    safe_parse_int(str2).flat_map do |b|
+      safe_divide(a, b)
+    end
+  end
+end
+
+parse_and_divide('10', '2')   # => [5]
+parse_and_divide('abc', '2')  # => []  (パースエラー)
+parse_and_divide('10', '0')   # => []  (ゼロ除算)
+```
+
+---
+
+## まとめ
+
+### Part II で学んだこと
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "Part II: 関数型スタイルのプログラミング" {
+  rectangle "第3章" as ch3 {
+    card "イミュータブルデータ"
+    card "take / drop / slice"
+    card "データ変換パターン"
+  }
+
+  rectangle "第4章" as ch4 {
+    card "高階関数"
+    card "map / select / reduce"
+    card "関数を返す関数"
+    card "カリー化"
+  }
+
+  rectangle "第5章" as ch5 {
+    card "flatten / flat_map"
+    card "ネストした変換"
+    card "デカルト積"
+    card "モナディックパターン"
+  }
+}
+
+ch3 --> ch4
+ch4 --> ch5
+
+@enduml
+```
+
+### キーポイント
+
+| 章 | 主要概念 | Ruby のキー操作 |
+|----|----------|----------------|
+| 第3章 | イミュータブル | `+`, `take`, `drop`, `[]` |
+| 第4章 | 高階関数 | `map`, `select`, `reduce`, `sort_by` |
+| 第5章 | 平坦化 | `flatten`, `flat_map` |
+
+### Scala との対応
+
+| Scala | Ruby | 説明 |
+|-------|------|------|
+| `appended` | `+ [elem]` | 要素追加 |
+| `slice` | `[start...end]` | 切り出し |
+| `map` | `map` | 変換 |
+| `filter` | `select` | 抽出 |
+| `foldLeft` | `reduce` | 畳み込み |
+| `flatMap` | `flat_map` | 平坦化変換 |
+| `case class` | `Struct` | データ構造 |
+| `=>` (lambda) | `->` (lambda) | 無名関数 |
+
+### 重要な法則
+
+1. **イミュータブルデータ**: 元のデータは変更せず、新しいデータを作成する
+2. **関数は値**: 関数を引数として渡したり、戻り値として返したりできる
+3. **flat_map パターン**: ネストした構造を平坦化しながら変換する
+4. **空配列によるエラー表現**: `[]` を返すことでエラーケースを表現できる
+
+### 次のステップ
+
+Part III では、以下のトピックを学びます:
+
+- dry-monads の `Maybe` 型による安全なエラーハンドリング
+- `Result` 型と複合的なエラー処理
+- モナディックな操作の実践
+
+---
+
+## 演習問題
+
+### 問題 1: イミュータブルな操作
+
+配列の中央に要素を挿入する関数を実装してください。
+
+```ruby
+def insert_at_middle(list, element)
+  # 実装してください
+end
+
+# 期待される動作
+insert_at_middle(%w[a b c d], 'X')  # => ["a", "b", "X", "c", "d"]
+insert_at_middle(%w[a b], 'X')      # => ["a", "X", "b"]
+```
+
+<details>
+<summary>解答</summary>
+
+```ruby
+def insert_at_middle(list, element)
+  middle = list.size / 2
+  before = list.take(middle)
+  after = list.drop(middle)
+  before + [element] + after
+end
+```
+
+</details>
+
+### 問題 2: 高階関数
+
+条件を満たす要素の数をカウントする関数を実装してください。
+
+```ruby
+def count_where(list, &predicate)
+  # 実装してください
+end
+
+# 期待される動作
+count_where([1, 2, 3, 4, 5]) { |i| i > 3 }  # => 2
+count_where(%w[a bb ccc]) { |s| s.length > 1 }  # => 2
+```
+
+<details>
+<summary>解答</summary>
+
+```ruby
+def count_where(list, &predicate)
+  list.count(&predicate)
+end
+
+# または reduce を使って
+def count_where2(list, &predicate)
+  list.reduce(0) { |count, elem| predicate.call(elem) ? count + 1 : count }
+end
+```
+
+</details>
+
+### 問題 3: flat_map
+
+以下のネストした flat_map をより読みやすく書き換えてください。
+
+```ruby
+result = [1, 2].flat_map do |x|
+  [10, 20].flat_map do |y|
+    [100, 200].map do |z|
+      x + y + z
+    end
+  end
+end
+```
+
+<details>
+<summary>解答</summary>
+
+```ruby
+# メソッドに分離
+def triplet_sums(xs, ys, zs)
+  xs.flat_map do |x|
+    ys.flat_map do |y|
+      zs.map do |z|
+        x + y + z
+      end
+    end
+  end
+end
+
+result = triplet_sums([1, 2], [10, 20], [100, 200])
+# => [111, 211, 121, 221, 112, 212, 122, 222]
+```
+
+</details>
+
+### 問題 4: flat_map によるフィルタリング
+
+`select` を使わずに、flat_map だけで偶数のみを抽出するコードを書いてください。
+
+```ruby
+numbers = [1, 2, 3, 4, 5, 6]
+# 偶数のみを抽出: [2, 4, 6]
+```
+
+<details>
+<summary>解答</summary>
+
+```ruby
+even_numbers = numbers.flat_map do |n|
+  n.even? ? [n] : []
+end
+
+# または関数に分離
+def even_filter(n)
+  n.even? ? [n] : []
+end
+
+even_numbers2 = numbers.flat_map { |n| even_filter(n) }
+```
+
+</details>