@k2works/claude-code-booster 4.11.0 → 4.12.0

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

@@ -1,755 +1,755 @@
-# Part I: 関数型プログラミングの基礎
-
-本章では、関数型プログラミング（FP）の基本概念を Ruby で学びます。命令型プログラミングとの違いを理解し、純粋関数の利点を実感することが目標です。
-
----
-
-## 第1章: 関数型プログラミング入門
-
-### 1.1 命令型 vs 関数型
-
-プログラミングには大きく分けて2つのパラダイムがあります。
-
-```plantuml
-@startuml
-!theme plain
-left to right direction
-
-rectangle "命令型プログラミング" as imp {
-  card "HOW（どうやるか）" as how
-  card "ステップバイステップ" as step
-  card "状態の変更" as state
-}
-
-rectangle "関数型プログラミング" as fp {
-  card "WHAT（何をするか）" as what
-  card "宣言的記述" as decl
-  card "値の変換" as transform
-}
-
-imp -[hidden]right-> fp
-@enduml
-```
-
-**命令型プログラミング**は「どうやるか」を記述します。
-
-**ソースファイル**: `app/ruby/lib/ch01_intro.rb`
-
-```ruby
-# 命令型: ステップバイステップでスコアを計算
-def calculate_score_imperative(word)
-  score = 0
-  word.each_char do |_c|
-    score += 1
-  end
-  score
-end
-```
-
-**関数型プログラミング**は「何をするか」を記述します。
-
-```ruby
-# 関数型: 宣言的にスコアを計算
-def word_score(word)
-  word.length
-end
-```
-
-### 1.2 Ruby の基本構文
-
-Ruby での関数定義の基本形を見てみましょう。
-
-```ruby
-module Ch01Intro
-  # 数値をインクリメント
-  def self.increment(x)
-    x + 1
-  end
-
-  # 文字列の最初の文字を取得
-  def self.get_first_character(s)
-    s[0]
-  end
-
-  # ワードスコア（文字数）を計算
-  def self.word_score(word)
-    word.length
-  end
-end
-```
-
-### 1.3 関数の構造
-
-```plantuml
-@startuml
-!theme plain
-skinparam rectangle {
-  BackgroundColor White
-  BorderColor Black
-}
-
-rectangle "def self.increment(x)" {
-  rectangle "def" as kw #LightBlue
-  rectangle "self." as scope #LightCyan
-  rectangle "increment" as name #LightGreen
-  rectangle "(x)" as params #LightYellow
-  rectangle "x + 1" as body #LightGray
-}
-
-note bottom of kw : キーワード
-note bottom of scope : モジュールメソッド
-note bottom of name : 関数名
-note bottom of params : パラメータ
-note bottom of body : 関数本体
-
-@enduml
-```
-
-### 1.4 条件分岐と述語関数
-
-Ruby では条件分岐を式として扱います。
-
-```ruby
-# 絶対値を返す
-def self.absolute(x)
-  x >= 0 ? x : -x
-end
-
-# 値をクランプ（範囲内に収める）
-def self.clamp(value, min_val, max_val)
-  min_value(max_value(value, min_val), max_val)
-end
-```
-
-**述語関数**（真偽値を返す関数）:
-
-```ruby
-# Ruby では ? で終わるメソッド名が慣例
-def self.even?(n)
-  (n % 2).zero?
-end
-
-def self.positive?(n)
-  n > 0
-end
-
-def self.empty?(s)
-  s.empty?
-end
-```
-
-### 1.5 学習ポイント
-
-| 概念 | 命令型 | 関数型 |
-|------|--------|--------|
-| 焦点 | 手順（How） | 結果（What） |
-| 状態 | 変更する | 変換する |
-| ループ | each/while | map/select/reduce |
-| データ | ミュータブル | イミュータブル |
-
----
-
-## 第2章: 純粋関数とテスト
-
-### 2.1 純粋関数とは
-
-純粋関数（Pure Function）は以下の特徴を持つ関数です:
-
-1. **同じ入力には常に同じ出力を返す**
-2. **副作用がない**（外部状態を変更しない）
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "純粋関数" as pure {
-  card "入力" as in
-  card "出力" as out
-  in -> out : 決定論的
-}
-
-rectangle "不純な関数" as impure {
-  card "入力" as in2
-  card "出力" as out2
-  card "外部状態" as state
-  in2 -> out2
-  state --> out2 : 影響
-  out2 --> state : 変更
-}
-
-@enduml
-```
-
-### 2.2 純粋関数の例
-
-**ソースファイル**: `app/ruby/lib/ch02_pure_functions.rb`
-
-```ruby
-module Ch02PureFunctions
-  # 純粋関数: 2つの数を加算
-  def self.add(a, b)
-    a + b
-  end
-
-  # 純粋関数: 文字列の長さを取得
-  def self.string_length(s)
-    s.length
-  end
-
-  # 純粋関数: ワードスコアを計算
-  def self.word_score(word)
-    word.length
-  end
-end
-```
-
-**純粋ではない関数の例**:
-
-```ruby
-# 不純: 毎回異なる値を返す
-def self.random_number_impure
-  rand
-end
-
-# 不純: 外部に出力（副作用）
-def self.print_impure(message)
-  puts message
-end
-
-# 不純: 現在時刻に依存
-def self.current_time_impure
-  Time.now
-end
-```
-
-### 2.3 ショッピングカートの例
-
-状態を持つクラスの問題点を見てみましょう。
-
-#### 問題のあるコード
-
-```ruby
-class ShoppingCartBad
-  def initialize
-    @items = []
-    @book_added = false
-  end
-
-  def add_item(item)
-    @items << item
-    @book_added = true if item == 'Book'
-  end
-
-  def discount_percentage
-    @book_added ? 5 : 0
-  end
-
-  def items
-    @items  # 問題: 内部状態への参照を返している
-  end
-end
-```
-
-```plantuml
-@startuml
-!theme plain
-skinparam sequence {
-  ArrowColor Black
-  LifeLineBorderColor Black
-}
-
-actor User
-participant "ShoppingCartBad" as cart
-participant "items (Array)" as list
-
-User -> cart: add_item("Book")
-cart -> list: push("Book")
-cart -> cart: @book_added = true
-
-User -> cart: items
-cart --> User: items の参照
-
-User -> list: delete("Book")
-note right: 外部から直接変更!
-
-User -> cart: discount_percentage
-cart --> User: 5 (@book_added は true のまま)
-
-note over User, list
-  カートに Book がないのに
-  割引が 5% のままになる!
-end note
-
-@enduml
-```
-
-#### 純粋関数による解決
-
-```ruby
-module ShoppingCart
-  # 純粋関数: 入力に基づいて割引を計算
-  def self.get_discount_percentage(items)
-    items.include?('Book') ? 5 : 0
-  end
-
-  def self.calculate_final_price(total, items)
-    discount_percentage = get_discount_percentage(items)
-    discount = total * discount_percentage / 100.0
-    total - discount
-  end
-end
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "純粋関数版 ShoppingCart" {
-  card "get_discount_percentage" as func
-
-  card "['Apple']" as in1
-  card "0" as out1
-
-  card "['Apple', 'Book']" as in2
-  card "5" as out2
-
-  in1 --> func
-  func --> out1
-
-  in2 --> func
-  func --> out2
-}
-
-note bottom
-  同じ入力には常に同じ出力
-  状態を持たない
-end note
-
-@enduml
-```
-
-### 2.4 チップ計算の例
-
-```ruby
-module TipCalculator
-  def self.get_tip_percentage(names)
-    if names.size > 5
-      20
-    elsif names.size > 0
-      10
-    else
-      0
-    end
-  end
-
-  def self.calculate_tip(bill_amount, names)
-    percentage = get_tip_percentage(names)
-    bill_amount * percentage / 100.0
-  end
-end
-```
-
-この関数は:
-
-
-- 6人以上のグループ → 20% のチップ
-- 1-5人のグループ → 10% のチップ
-- 0人（空リスト） → 0% のチップ
-
-### 2.5 純粋関数のテスト
-
-純粋関数は非常にテストしやすいです。
-
-```ruby
-RSpec.describe Ch02PureFunctions do
-  describe '.word_score' do
-    it 'returns the length of the word' do
-      expect(described_class.word_score('Ruby')).to eq(4)
-    end
-
-    it 'is deterministic (same input = same output)' do
-      score1 = described_class.word_score('Scala')
-      score2 = described_class.word_score('Scala')
-      expect(score1).to eq(score2)
-    end
-  end
-
-  describe '.get_discount_percentage' do
-    it 'returns 5% when cart contains Book' do
-      expect(described_class.get_discount_percentage(%w[Apple Book])).to eq(5)
-    end
-
-    it 'returns 0% when cart does not contain Book' do
-      expect(described_class.get_discount_percentage(%w[Apple])).to eq(0)
-    end
-  end
-end
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "テストの特徴比較" {
-  rectangle "純粋関数のテスト" as pure {
-    card "セットアップ不要" as s1
-    card "独立して実行可能" as s2
-    card "決定論的" as s3
-    card "高速" as s4
-  }
-
-  rectangle "状態を持つコードのテスト" as impure {
-    card "セットアップ必要" as i1
-    card "実行順序に依存" as i2
-    card "非決定論的になりやすい" as i3
-    card "モック/スタブが必要" as i4
-  }
-}
-
-@enduml
-```
-
-### 2.6 文字 'a' を除外するワードスコア
-
-より複雑な例を見てみましょう。
-
-```ruby
-def self.word_score_no_a(word)
-  word.gsub(/[aA]/, '').length
-end
-
-# テスト
-expect(word_score_no_a('Scala')).to eq(3)   # "Scl" → 3文字
-expect(word_score_no_a('function')).to eq(8) # 'a' なし → 8文字
-expect(word_score_no_a('')).to eq(0)         # 空文字 → 0文字
-```
-
-### 2.7 参照透過性
-
-純粋関数は**参照透過性（Referential Transparency）**を持ちます。
-
-> 式をその評価結果で置き換えても、プログラムの意味が変わらないこと
-
-```ruby
-# 参照透過性の例
-score1 = word_score('Scala')
-score2 = word_score('Scala')
-# score1 と score2 は常に同じ値（5）
-
-# 以下の2つは同等
-total1 = word_score('Scala') + word_score('Java')
-total2 = 5 + 4  # word_score の結果で置き換え可能
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "参照透過性" {
-  card "word_score('Scala')" as expr
-  card "5" as value
-
-  expr <--> value : 常に置換可能
-}
-
-note bottom
-  式をその結果で置き換えても
-  プログラムの動作は変わらない
-end note
-
-@enduml
-```
-
-### 2.8 Ruby でのイミュータビリティ
-
-Ruby ではオブジェクトを `freeze` でイミュータブルにできます。
-
-```ruby
-# freeze でオブジェクトを不変にする
-str = 'hello'.freeze
-str.upcase!  # => FrozenError!
-
-# 深い freeze
-def self.deep_freeze(obj)
-  case obj
-  when Array
-    obj.each { |item| deep_freeze(item) }
-    obj.freeze
-  when Hash
-    obj.each_value { |value| deep_freeze(value) }
-    obj.freeze
-  else
-    obj.freeze if obj.respond_to?(:freeze)
-  end
-  obj
-end
-
-# イミュータブルな配列を作成
-arr = deep_freeze([1, 2, 3])
-arr << 4  # => FrozenError!
-```
-
-### 2.9 高階関数の基礎
-
-関数を値として扱う:
-
-```ruby
-# 関数を引数として受け取る
-def self.apply_twice(f, x)
-  f.call(f.call(x))
-end
-
-increment = ->(x) { x + 1 }
-apply_twice(increment, 5)  # => 7
-
-# 関数を返す
-def self.compose(f, g)
-  ->(x) { f.call(g.call(x)) }
-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)
-```
-
----
-
-## まとめ
-
-### Part I で学んだこと
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "Part I: 関数型プログラミングの基礎" {
-  rectangle "第1章" as ch1 {
-    card "命令型 vs 関数型"
-    card "Ruby 基本構文"
-    card "HOW から WHAT へ"
-  }
-
-  rectangle "第2章" as ch2 {
-    card "純粋関数"
-    card "副作用の排除"
-    card "テストの容易さ"
-    card "参照透過性"
-  }
-}
-
-ch1 --> ch2
-
-@enduml
-```
-
-### キーポイント
-
-1. **関数型プログラミング**は「何をするか」を宣言的に記述する
-2. **純粋関数**は同じ入力に対して常に同じ出力を返す
-3. **副作用**を避けることでコードの予測可能性が向上する
-4. **純粋関数**はテストが非常に簡単
-5. **参照透過性**により、コードの理解と推論が容易になる
-6. **freeze**を使ってイミュータビリティを強制できる
-
-### 次のステップ
-
-Part II では、以下のトピックを学びます:
-
-- dry-struct によるイミュータブルなデータ構造
-- Enumerable による高階関数操作
-- flat_map とチェイニング
-
----
-
-## 演習問題
-
-### 問題 1: 純粋関数の識別
-
-以下の関数のうち、純粋関数はどれですか?
-
-```ruby
-# A
-def double(x)
-  x * 2
-end
-
-# B
-$counter = 0
-def increment_counter
-  $counter += 1
-  $counter
-end
-
-# C
-def greet(name)
-  "Hello, #{name}!"
-end
-
-# D
-def current_time
-  Time.now
-end
-```
-
-<details>
-<summary>解答</summary>
-
-**A と C は純粋関数**です。
-
-- A: 同じ入力に対して常に同じ出力を返し、副作用がない
-- B: グローバル変数 `$counter` を変更する副作用がある（不純）
-- C: 同じ入力に対して常に同じ出力を返し、副作用がない
-- D: 呼び出すたびに異なる値を返す（不純）
-
-</details>
-
-### 問題 2: 純粋関数への書き換え
-
-以下の不純なクラスを純粋関数に書き換えてください。
-
-```ruby
-class Counter
-  def initialize
-    @value = 0
-  end
-
-  def increment
-    @value += 1
-    @value
-  end
-end
-```
-
-<details>
-<summary>解答</summary>
-
-```ruby
-module Counter
-  def self.increment(value)
-    value + 1
-  end
-end
-
-# 使用例
-v1 = 0
-v2 = Counter.increment(v1)  # 1
-v3 = Counter.increment(v2)  # 2
-```
-
-状態を外部に持ち、関数は値を受け取って新しい値を返すだけにします。
-
-</details>
-
-### 問題 3: テストを書く
-
-以下の関数に対するテストケースを考えてください。
-
-```ruby
-def even?(n)
-  (n % 2).zero?
-end
-```
-
-<details>
-<summary>解答</summary>
-
-```ruby
-RSpec.describe '#even?' do
-  # 基本ケース
-  it 'returns true for 0' do
-    expect(even?(0)).to be true
-  end
-
-  it 'returns true for even positive numbers' do
-    expect(even?(2)).to be true
-    expect(even?(4)).to be true
-  end
-
-  it 'returns false for odd numbers' do
-    expect(even?(1)).to be false
-    expect(even?(3)).to be false
-  end
-
-  # 負の数
-  it 'returns true for negative even numbers' do
-    expect(even?(-2)).to be true
-  end
-
-  it 'returns false for negative odd numbers' do
-    expect(even?(-3)).to be false
-  end
-end
-```
-
-</details>
-
-### 問題 4: 高階関数
-
-`apply_twice` を使って、数値を4倍する関数を作成してください。
-
-<details>
-<summary>解答</summary>
-
-```ruby
-def apply_twice(f, x)
-  f.call(f.call(x))
-end
-
-double = ->(x) { x * 2 }
-
-# apply_twice で2回 double を適用 = 4倍
-result = apply_twice(double, 5)  # => 20
-
-# または新しい関数として
-quadruple = ->(x) { apply_twice(double, x) }
-quadruple.call(3)  # => 12
-```
-
-</details>
-
-### 問題 5: freeze の使用
-
-以下の配列を深くフリーズして、変更不可能にしてください。
-
-```ruby
-data = [
-  { name: 'Alice', scores: [90, 85, 92] },
-  { name: 'Bob', scores: [78, 82, 88] }
-]
-```
-
-<details>
-<summary>解答</summary>
-
-```ruby
-def deep_freeze(obj)
-  case obj
-  when Array
-    obj.each { |item| deep_freeze(item) }
-    obj.freeze
-  when Hash
-    obj.each_value { |value| deep_freeze(value) }
-    obj.freeze
-  when String
-    obj.freeze
-  else
-    obj.freeze if obj.respond_to?(:freeze)
-  end
-  obj
-end
-
-data = [
-  { name: 'Alice', scores: [90, 85, 92] },
-  { name: 'Bob', scores: [78, 82, 88] }
-]
-
-frozen_data = deep_freeze(data)
-
-# これらはすべて FrozenError を発生させる
-frozen_data << {}                    # エラー
-frozen_data[0][:name] = 'Carol'      # エラー
-frozen_data[0][:scores] << 95        # エラー
-```
-
-</details>
+# Part I: 関数型プログラミングの基礎
+
+本章では、関数型プログラミング（FP）の基本概念を Ruby で学びます。命令型プログラミングとの違いを理解し、純粋関数の利点を実感することが目標です。
+
+---
+
+## 第1章: 関数型プログラミング入門
+
+### 1.1 命令型 vs 関数型
+
+プログラミングには大きく分けて2つのパラダイムがあります。
+
+```plantuml
+@startuml
+!theme plain
+left to right direction
+
+rectangle "命令型プログラミング" as imp {
+  card "HOW（どうやるか）" as how
+  card "ステップバイステップ" as step
+  card "状態の変更" as state
+}
+
+rectangle "関数型プログラミング" as fp {
+  card "WHAT（何をするか）" as what
+  card "宣言的記述" as decl
+  card "値の変換" as transform
+}
+
+imp -[hidden]right-> fp
+@enduml
+```
+
+**命令型プログラミング**は「どうやるか」を記述します。
+
+**ソースファイル**: `app/ruby/lib/ch01_intro.rb`
+
+```ruby
+# 命令型: ステップバイステップでスコアを計算
+def calculate_score_imperative(word)
+  score = 0
+  word.each_char do |_c|
+    score += 1
+  end
+  score
+end
+```
+
+**関数型プログラミング**は「何をするか」を記述します。
+
+```ruby
+# 関数型: 宣言的にスコアを計算
+def word_score(word)
+  word.length
+end
+```
+
+### 1.2 Ruby の基本構文
+
+Ruby での関数定義の基本形を見てみましょう。
+
+```ruby
+module Ch01Intro
+  # 数値をインクリメント
+  def self.increment(x)
+    x + 1
+  end
+
+  # 文字列の最初の文字を取得
+  def self.get_first_character(s)
+    s[0]
+  end
+
+  # ワードスコア（文字数）を計算
+  def self.word_score(word)
+    word.length
+  end
+end
+```
+
+### 1.3 関数の構造
+
+```plantuml
+@startuml
+!theme plain
+skinparam rectangle {
+  BackgroundColor White
+  BorderColor Black
+}
+
+rectangle "def self.increment(x)" {
+  rectangle "def" as kw #LightBlue
+  rectangle "self." as scope #LightCyan
+  rectangle "increment" as name #LightGreen
+  rectangle "(x)" as params #LightYellow
+  rectangle "x + 1" as body #LightGray
+}
+
+note bottom of kw : キーワード
+note bottom of scope : モジュールメソッド
+note bottom of name : 関数名
+note bottom of params : パラメータ
+note bottom of body : 関数本体
+
+@enduml
+```
+
+### 1.4 条件分岐と述語関数
+
+Ruby では条件分岐を式として扱います。
+
+```ruby
+# 絶対値を返す
+def self.absolute(x)
+  x >= 0 ? x : -x
+end
+
+# 値をクランプ（範囲内に収める）
+def self.clamp(value, min_val, max_val)
+  min_value(max_value(value, min_val), max_val)
+end
+```
+
+**述語関数**（真偽値を返す関数）:
+
+```ruby
+# Ruby では ? で終わるメソッド名が慣例
+def self.even?(n)
+  (n % 2).zero?
+end
+
+def self.positive?(n)
+  n > 0
+end
+
+def self.empty?(s)
+  s.empty?
+end
+```
+
+### 1.5 学習ポイント
+
+| 概念 | 命令型 | 関数型 |
+|------|--------|--------|
+| 焦点 | 手順（How） | 結果（What） |
+| 状態 | 変更する | 変換する |
+| ループ | each/while | map/select/reduce |
+| データ | ミュータブル | イミュータブル |
+
+---
+
+## 第2章: 純粋関数とテスト
+
+### 2.1 純粋関数とは
+
+純粋関数（Pure Function）は以下の特徴を持つ関数です:
+
+1. **同じ入力には常に同じ出力を返す**
+2. **副作用がない**（外部状態を変更しない）
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "純粋関数" as pure {
+  card "入力" as in
+  card "出力" as out
+  in -> out : 決定論的
+}
+
+rectangle "不純な関数" as impure {
+  card "入力" as in2
+  card "出力" as out2
+  card "外部状態" as state
+  in2 -> out2
+  state --> out2 : 影響
+  out2 --> state : 変更
+}
+
+@enduml
+```
+
+### 2.2 純粋関数の例
+
+**ソースファイル**: `app/ruby/lib/ch02_pure_functions.rb`
+
+```ruby
+module Ch02PureFunctions
+  # 純粋関数: 2つの数を加算
+  def self.add(a, b)
+    a + b
+  end
+
+  # 純粋関数: 文字列の長さを取得
+  def self.string_length(s)
+    s.length
+  end
+
+  # 純粋関数: ワードスコアを計算
+  def self.word_score(word)
+    word.length
+  end
+end
+```
+
+**純粋ではない関数の例**:
+
+```ruby
+# 不純: 毎回異なる値を返す
+def self.random_number_impure
+  rand
+end
+
+# 不純: 外部に出力（副作用）
+def self.print_impure(message)
+  puts message
+end
+
+# 不純: 現在時刻に依存
+def self.current_time_impure
+  Time.now
+end
+```
+
+### 2.3 ショッピングカートの例
+
+状態を持つクラスの問題点を見てみましょう。
+
+#### 問題のあるコード
+
+```ruby
+class ShoppingCartBad
+  def initialize
+    @items = []
+    @book_added = false
+  end
+
+  def add_item(item)
+    @items << item
+    @book_added = true if item == 'Book'
+  end
+
+  def discount_percentage
+    @book_added ? 5 : 0
+  end
+
+  def items
+    @items  # 問題: 内部状態への参照を返している
+  end
+end
+```
+
+```plantuml
+@startuml
+!theme plain
+skinparam sequence {
+  ArrowColor Black
+  LifeLineBorderColor Black
+}
+
+actor User
+participant "ShoppingCartBad" as cart
+participant "items (Array)" as list
+
+User -> cart: add_item("Book")
+cart -> list: push("Book")
+cart -> cart: @book_added = true
+
+User -> cart: items
+cart --> User: items の参照
+
+User -> list: delete("Book")
+note right: 外部から直接変更!
+
+User -> cart: discount_percentage
+cart --> User: 5 (@book_added は true のまま)
+
+note over User, list
+  カートに Book がないのに
+  割引が 5% のままになる!
+end note
+
+@enduml
+```
+
+#### 純粋関数による解決
+
+```ruby
+module ShoppingCart
+  # 純粋関数: 入力に基づいて割引を計算
+  def self.get_discount_percentage(items)
+    items.include?('Book') ? 5 : 0
+  end
+
+  def self.calculate_final_price(total, items)
+    discount_percentage = get_discount_percentage(items)
+    discount = total * discount_percentage / 100.0
+    total - discount
+  end
+end
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "純粋関数版 ShoppingCart" {
+  card "get_discount_percentage" as func
+
+  card "['Apple']" as in1
+  card "0" as out1
+
+  card "['Apple', 'Book']" as in2
+  card "5" as out2
+
+  in1 --> func
+  func --> out1
+
+  in2 --> func
+  func --> out2
+}
+
+note bottom
+  同じ入力には常に同じ出力
+  状態を持たない
+end note
+
+@enduml
+```
+
+### 2.4 チップ計算の例
+
+```ruby
+module TipCalculator
+  def self.get_tip_percentage(names)
+    if names.size > 5
+      20
+    elsif names.size > 0
+      10
+    else
+      0
+    end
+  end
+
+  def self.calculate_tip(bill_amount, names)
+    percentage = get_tip_percentage(names)
+    bill_amount * percentage / 100.0
+  end
+end
+```
+
+この関数は:
+
+
+- 6人以上のグループ → 20% のチップ
+- 1-5人のグループ → 10% のチップ
+- 0人（空リスト） → 0% のチップ
+
+### 2.5 純粋関数のテスト
+
+純粋関数は非常にテストしやすいです。
+
+```ruby
+RSpec.describe Ch02PureFunctions do
+  describe '.word_score' do
+    it 'returns the length of the word' do
+      expect(described_class.word_score('Ruby')).to eq(4)
+    end
+
+    it 'is deterministic (same input = same output)' do
+      score1 = described_class.word_score('Scala')
+      score2 = described_class.word_score('Scala')
+      expect(score1).to eq(score2)
+    end
+  end
+
+  describe '.get_discount_percentage' do
+    it 'returns 5% when cart contains Book' do
+      expect(described_class.get_discount_percentage(%w[Apple Book])).to eq(5)
+    end
+
+    it 'returns 0% when cart does not contain Book' do
+      expect(described_class.get_discount_percentage(%w[Apple])).to eq(0)
+    end
+  end
+end
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "テストの特徴比較" {
+  rectangle "純粋関数のテスト" as pure {
+    card "セットアップ不要" as s1
+    card "独立して実行可能" as s2
+    card "決定論的" as s3
+    card "高速" as s4
+  }
+
+  rectangle "状態を持つコードのテスト" as impure {
+    card "セットアップ必要" as i1
+    card "実行順序に依存" as i2
+    card "非決定論的になりやすい" as i3
+    card "モック/スタブが必要" as i4
+  }
+}
+
+@enduml
+```
+
+### 2.6 文字 'a' を除外するワードスコア
+
+より複雑な例を見てみましょう。
+
+```ruby
+def self.word_score_no_a(word)
+  word.gsub(/[aA]/, '').length
+end
+
+# テスト
+expect(word_score_no_a('Scala')).to eq(3)   # "Scl" → 3文字
+expect(word_score_no_a('function')).to eq(8) # 'a' なし → 8文字
+expect(word_score_no_a('')).to eq(0)         # 空文字 → 0文字
+```
+
+### 2.7 参照透過性
+
+純粋関数は**参照透過性（Referential Transparency）**を持ちます。
+
+> 式をその評価結果で置き換えても、プログラムの意味が変わらないこと
+
+```ruby
+# 参照透過性の例
+score1 = word_score('Scala')
+score2 = word_score('Scala')
+# score1 と score2 は常に同じ値（5）
+
+# 以下の2つは同等
+total1 = word_score('Scala') + word_score('Java')
+total2 = 5 + 4  # word_score の結果で置き換え可能
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "参照透過性" {
+  card "word_score('Scala')" as expr
+  card "5" as value
+
+  expr <--> value : 常に置換可能
+}
+
+note bottom
+  式をその結果で置き換えても
+  プログラムの動作は変わらない
+end note
+
+@enduml
+```
+
+### 2.8 Ruby でのイミュータビリティ
+
+Ruby ではオブジェクトを `freeze` でイミュータブルにできます。
+
+```ruby
+# freeze でオブジェクトを不変にする
+str = 'hello'.freeze
+str.upcase!  # => FrozenError!
+
+# 深い freeze
+def self.deep_freeze(obj)
+  case obj
+  when Array
+    obj.each { |item| deep_freeze(item) }
+    obj.freeze
+  when Hash
+    obj.each_value { |value| deep_freeze(value) }
+    obj.freeze
+  else
+    obj.freeze if obj.respond_to?(:freeze)
+  end
+  obj
+end
+
+# イミュータブルな配列を作成
+arr = deep_freeze([1, 2, 3])
+arr << 4  # => FrozenError!
+```
+
+### 2.9 高階関数の基礎
+
+関数を値として扱う:
+
+```ruby
+# 関数を引数として受け取る
+def self.apply_twice(f, x)
+  f.call(f.call(x))
+end
+
+increment = ->(x) { x + 1 }
+apply_twice(increment, 5)  # => 7
+
+# 関数を返す
+def self.compose(f, g)
+  ->(x) { f.call(g.call(x)) }
+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)
+```
+
+---
+
+## まとめ
+
+### Part I で学んだこと
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "Part I: 関数型プログラミングの基礎" {
+  rectangle "第1章" as ch1 {
+    card "命令型 vs 関数型"
+    card "Ruby 基本構文"
+    card "HOW から WHAT へ"
+  }
+
+  rectangle "第2章" as ch2 {
+    card "純粋関数"
+    card "副作用の排除"
+    card "テストの容易さ"
+    card "参照透過性"
+  }
+}
+
+ch1 --> ch2
+
+@enduml
+```
+
+### キーポイント
+
+1. **関数型プログラミング**は「何をするか」を宣言的に記述する
+2. **純粋関数**は同じ入力に対して常に同じ出力を返す
+3. **副作用**を避けることでコードの予測可能性が向上する
+4. **純粋関数**はテストが非常に簡単
+5. **参照透過性**により、コードの理解と推論が容易になる
+6. **freeze**を使ってイミュータビリティを強制できる
+
+### 次のステップ
+
+Part II では、以下のトピックを学びます:
+
+- dry-struct によるイミュータブルなデータ構造
+- Enumerable による高階関数操作
+- flat_map とチェイニング
+
+---
+
+## 演習問題
+
+### 問題 1: 純粋関数の識別
+
+以下の関数のうち、純粋関数はどれですか?
+
+```ruby
+# A
+def double(x)
+  x * 2
+end
+
+# B
+$counter = 0
+def increment_counter
+  $counter += 1
+  $counter
+end
+
+# C
+def greet(name)
+  "Hello, #{name}!"
+end
+
+# D
+def current_time
+  Time.now
+end
+```
+
+<details>
+<summary>解答</summary>
+
+**A と C は純粋関数**です。
+
+- A: 同じ入力に対して常に同じ出力を返し、副作用がない
+- B: グローバル変数 `$counter` を変更する副作用がある（不純）
+- C: 同じ入力に対して常に同じ出力を返し、副作用がない
+- D: 呼び出すたびに異なる値を返す（不純）
+
+</details>
+
+### 問題 2: 純粋関数への書き換え
+
+以下の不純なクラスを純粋関数に書き換えてください。
+
+```ruby
+class Counter
+  def initialize
+    @value = 0
+  end
+
+  def increment
+    @value += 1
+    @value
+  end
+end
+```
+
+<details>
+<summary>解答</summary>
+
+```ruby
+module Counter
+  def self.increment(value)
+    value + 1
+  end
+end
+
+# 使用例
+v1 = 0
+v2 = Counter.increment(v1)  # 1
+v3 = Counter.increment(v2)  # 2
+```
+
+状態を外部に持ち、関数は値を受け取って新しい値を返すだけにします。
+
+</details>
+
+### 問題 3: テストを書く
+
+以下の関数に対するテストケースを考えてください。
+
+```ruby
+def even?(n)
+  (n % 2).zero?
+end
+```
+
+<details>
+<summary>解答</summary>
+
+```ruby
+RSpec.describe '#even?' do
+  # 基本ケース
+  it 'returns true for 0' do
+    expect(even?(0)).to be true
+  end
+
+  it 'returns true for even positive numbers' do
+    expect(even?(2)).to be true
+    expect(even?(4)).to be true
+  end
+
+  it 'returns false for odd numbers' do
+    expect(even?(1)).to be false
+    expect(even?(3)).to be false
+  end
+
+  # 負の数
+  it 'returns true for negative even numbers' do
+    expect(even?(-2)).to be true
+  end
+
+  it 'returns false for negative odd numbers' do
+    expect(even?(-3)).to be false
+  end
+end
+```
+
+</details>
+
+### 問題 4: 高階関数
+
+`apply_twice` を使って、数値を4倍する関数を作成してください。
+
+<details>
+<summary>解答</summary>
+
+```ruby
+def apply_twice(f, x)
+  f.call(f.call(x))
+end
+
+double = ->(x) { x * 2 }
+
+# apply_twice で2回 double を適用 = 4倍
+result = apply_twice(double, 5)  # => 20
+
+# または新しい関数として
+quadruple = ->(x) { apply_twice(double, x) }
+quadruple.call(3)  # => 12
+```
+
+</details>
+
+### 問題 5: freeze の使用
+
+以下の配列を深くフリーズして、変更不可能にしてください。
+
+```ruby
+data = [
+  { name: 'Alice', scores: [90, 85, 92] },
+  { name: 'Bob', scores: [78, 82, 88] }
+]
+```
+
+<details>
+<summary>解答</summary>
+
+```ruby
+def deep_freeze(obj)
+  case obj
+  when Array
+    obj.each { |item| deep_freeze(item) }
+    obj.freeze
+  when Hash
+    obj.each_value { |value| deep_freeze(value) }
+    obj.freeze
+  when String
+    obj.freeze
+  else
+    obj.freeze if obj.respond_to?(:freeze)
+  end
+  obj
+end
+
+data = [
+  { name: 'Alice', scores: [90, 85, 92] },
+  { name: 'Bob', scores: [78, 82, 88] }
+]
+
+frozen_data = deep_freeze(data)
+
+# これらはすべて FrozenError を発生させる
+frozen_data << {}                    # エラー
+frozen_data[0][:name] = 'Carol'      # エラー
+frozen_data[0][:scores] << 95        # エラー
+```
+
+</details>