Ruby 入門

Ruby Proc と Lambda

Ruby において、Proc と Lambda はコードブロック（Code Blocks）をオブジェクト（Objects）としてハンドリングするためのコアツールです。これらはコードのビヘイビア（振る舞い）をカプセル化し、データのようにパッシング（伝達）し、未来の任意のタイミングでエグゼキュート（実行）することを可能にします。これにより、コードのリユース（再利用）、フレキシビリティ、そして関数型プログラミングのテクニックに対する強力な可能性が開かれます。

Proc と Lambda を理解することは、よりエクスプレッシブ（表現豊か）でメンテナブル（保守性の高い）な Ruby コードを記述する上で極めて重要です。前章のメソッドとコードブロックに関するナレッジに基づき、本章ではそれらの特性、ディファレンス（違い）、および実践的なアプリケーションについて深く解析します。

1. Proc を理解する

Proc（「procedure：プロシージャ」の略）は、コードブロックをオブジェクトにカプセル化するためのアプローチです。カプセル化されたオブジェクトはバリアブル（変数）にストア（保存）し、パラメータとしてメソッドにパッシングし、さらにはメソッドからリターンさせることができます。本質的に、Proc はコードブロックを Ruby プログラムにおける「ファーストクラスシチズン（第一級オブジェクト）」へとコンバートします。

1.1 Proc のクリエイト

Ruby で Proc をクリエイトするには、いくつかの一般的なアプローチがあります：

  • Proc.new のユース： これが最も一般的で明示的なクリエイト方法です。コードブロックを Proc.new にパッシングすると、Proc オブジェクトがリターンされます。
# Proc.new を使用して Proc をクリエイトする
my_proc = Proc.new { puts "Proc 内部からの挨拶です！" }

# この Proc をコールする
my_proc.call
  • proc キーワードのユース：proc は Proc.new と等価なキーワードです。Proc をクリエイトするためのよりコンサイス（簡潔）なシンタックスを提供します。
# 'proc' キーワードを使用して Proc をクリエイトする
my_proc = proc { puts "Proc 内部からの挨拶です！" }

# この Proc をコールする
my_proc.call
  • メソッドの Proc 変換オペレーター (&)： メソッドをパラメータとして別のメソッドにパッシングする際、& オペレーターを使用して該当メソッドを Proc にコンバートできます。これは、既存のメソッドをコードブロックとしてユースしたい場合に非常に便利です。
def my_method(arg)
  puts "メソッドがコールされました。パラメータ: #{arg}"
end

# & オペレーターを使用してメソッドを proc にコンバートするサンプル
def another_method(proc)
  proc.call("Hello")
end

another_method(&method(:my_method)) # パッシングする前に my_method を proc にコンバートする

1.2 Proc のコール

Proc オブジェクトを取得したら、call メソッドまたは [] オペレーターを使用して、それが包含するコードをエグゼキュートできます。

# 'call' メソッドのユース
my_proc = Proc.new { |name| puts "こんにちは、#{name}！" }
my_proc.call("Alice")

# '[]' オペレーターのユース（call と等価）
my_proc = Proc.new { |name| puts "こんにちは、#{name}！" }
my_proc["Bob"]

1.3 Proc のパラメータハンドリング

Proc はパラメータをハンドリングする際、非常にフレキシブルです。厳密なパラメータ数（Arity：アリティ）を強制しません。つまり、ディファインされた数よりも多い、あるいは少ないパラメータで Proc をコールすることが可能です。

  • パラメータが少なすぎる場合： Proc のコール時に提供されたパラメータが期待値より少ない場合、欠落したパラメータには nil がアサインされます。
my_proc = Proc.new { |x, y| puts "x: #{x}, y: #{y}" }
my_proc.call(1)  # アウトプット: x: 1, y: 
my_proc.call(1,2) # アウトプット: x: 1, y: 2
  • パラメータが多すぎる場合： Proc のコール時に提供されたパラメータが期待値より多い場合、余剰なパラメータは直接イグノア（無視）されます。
my_proc = Proc.new { |x, y| puts "x: #{x}, y: #{y}" }
my_proc.call(1, 2, 3)  # アウトプット: x: 1, y: 2

1.4 サンプル：クロージャ (Closure) としての Proc

Proc は、それがディファインされたスコープ（Scope）へのアクセス権をキープします。これは、その環境がもはや存在しなくなった後でも、周囲の環境のバリアブルを「記憶」できることを意味します。この特性はクロージャ (Closure) と呼ばれます。

def counter
  count = 0
  Proc.new { count += 1; puts count }
end

my_counter = counter  # my_counter は counter メソッドからリターンされた Proc
my_counter.call # アウトプット: 1
my_counter.call # アウトプット: 2
my_counter.call # アウトプット: 3

このサンプルにおいて、counter メソッド内部でクリエイトされた Proc は、counter メソッドのエグゼキュートが完了してリターンした後でも、count バリアブルへのアクセス権を保持しています。my_counter.call がエグゼキュートされるたびに、count の値をインクリメントしてプリントします。

2. Lambda を理解する

Lambda は、Ruby においてコードブロックをオブジェクトとしてディファインするもう一つのアプローチです。Proc と同様に、Lambda もバリアブルにストアし、パラメータとしてパッシングし、メソッドからリターンさせることができます。しかし、Lambda と Proc の間には、特にパラメータのハンドリングと return ステートメントのビヘイビアに関して、いくつかのコアなディファレンスが存在します。

2.1 Lambda のクリエイト

Lambda をクリエイトするには主に2つのアプローチがあります：

  • lambda キーワードのユース： これが Lambda をディファインする最も一般的な方法です。Proc.new と類似していますが、アンダーライイング（基盤となる）ビヘイビアが異なります。
# 'lambda' キーワードを使用して Lambda をクリエイト
my_lambda = lambda { |name| puts "こんにちは、#{name}！" }

# Lambda のコール
my_lambda.call("Charlie")
  • -> のユース（アローシンタックス / Stabby lambda）： このシンタックスは、特にショートなシングルラインの Lambda に適した、よりコンサイスな Lambda ディファインのアプローチを提供します。
# '->' シンタックスを使用して Lambda をクリエイト
my_lambda = ->(name) { puts "こんにちは、#{name}！" }

# Lambda のコール
my_lambda.call("Diana")

2.2 Lambda のコール

Lambda をコールするアプローチは Proc をコールするアプローチと完全に同一です：call メソッドまたは [] オペレーターを使用します。

# 'call' メソッドのユース
my_lambda = lambda { |name| puts "こんにちは、#{name}！" }
my_lambda.call("Eve")

# '[]' オペレーターのユース
my_lambda = lambda { |name| puts "こんにちは、#{name}！" }
my_lambda["Frank"]

2.3 Lambda のパラメータハンドリング (Arity)

Proc とは異なり、Lambda は厳密なパラメータ数（Arity）を強制します。つまり、Lambda をコールする際は、期待される数と完全に一致するパラメータをプロバイドする必要があります。提供されたパラメータ数が不正な場合、プログラムは ArgumentError エクセプション（例外）をスローします。

my_lambda = lambda { |x, y| puts "x: #{x}, y: #{y}" }

# 以下のコード行は ArgumentError をスローします: wrong number of arguments (given 1, expected 2)
# my_lambda.call(1)

# 以下のコード行は ArgumentError をスローします: wrong number of arguments (given 3, expected 2)
# my_lambda.call(1, 2, 3)

my_lambda.call(1,2) # アウトプット: x: 1, y: 2

2.4 Lambda における return ステートメント

Lambda 内部の return ステートメントのビヘイビアは Proc とは異なります。Lambda において、return ステートメントは Lambda 自身のみをエグジットし、コントロールをそれをコールしたメソッドにリターンします。これはレギュラーなメソッドにおける return のワークフローと非常に似ています。

(注：Proc 内で return を使用した場合、その Proc をディファインしている外部メソッド全体からエグジットしようと試みます。)

def my_method
  my_lambda = lambda { return "Lambda からのリターン" }
  result = my_lambda.call
  puts "このコード行はエグゼキュートされます"
  return result
end

puts my_method 
# アウトプット: このコード行はエグゼキュートされます
#         Lambda からのリターン

このサンプルにおいて、my_lambda 内部の return は Lambda ブロックのみをエグジットします。後続の puts "このコード行はエグゼキュートされます" は依然として正常にランし、最終的に my_method は Lambda がプロバイドした値をリターンします。

2.5 サンプル：データバリデーションへの Lambda のユース

Lambda は、コンピュート（計算）を実行する前に特定のコンディションが満たされていることを確認する必要があるデータバリデーション（Data Validation）のシナリオで頻繁にユースされます。Lambda の厳密なパラメータ要件は、このタスクに非常に適しています。

def process_data(data, validator)
  if validator.call(data)
    puts "データは有効です。処理中..."
    # ここでデータ処理をエグゼキュートする
  else
    puts "データは無効です。オペレーションをアボートします。"
  end
end

is_number = ->(x) { x.is_a? Numeric }

process_data(10, is_number)     # アウトプット: データは有効です。処理中...
process_data("abc", is_number)  # アウトプット: データは無効です。オペレーションをアボートします。

3. Proc と Lambda のコアな差異

特性ProcLambda
パラメータ数 (Arity)厳密ではない（パラメータの欠落や余剰を許容）厳密（規定されたパラメータ数と完全にマッチする必要あり）
return のビヘイビア当該 Proc を包含する外部メソッドからリターンするLambda コードブロック自身のみからリターンする
クリエイトのアプローチProc.new, proclambda, ->
タイプチェック比較的ルーズ比較的厳密

4. Proc と Lambda の選択

Proc と Lambda のどちらをユースするかは、コードの具体的な要件に依存します。

Lambda のユースを推奨するシナリオ：

  • 厳密なパラメータのチェックが必要な場合。
  • return ステートメントのビヘイビアをレギュラーなメソッドと同様にしたい場合（カレントのコードブロックのみをスキップする）。
  • コードブロックが期待通りの数のパラメータを確実にレシーブするようにしたい場合。

Proc のユースを推奨するシナリオ：

  • パラメータのパッシングにおいて極めて高いフレキシビリティが必要な場合（余剰パラメータのイグノアや欠落パラメータの許容）。
  • return ステートメントによって、包含する外部メソッド全体を直接インターラプト（中断）およびエグジットさせたい場合。
  • ハンドリングしている API やコードがブロックをレシーブすることを期待しているが、厳密なパラメータバリデーションを強制しない場合。

5. 実践ユースケースとデモンストレーション

5.1 ケース 1：Proc をユースしたデータフォーマット

データを異なるアプローチでフォーマットしたいと仮定します。Proc を使用してフォーマットのロジックをカプセル化できます。

def format_data(data, formatter)
  formatter.call(data)
end

to_uppercase = Proc.new { |str| str.upcase }
to_lowercase = Proc.new { |str| str.downcase }

data = "Hello World"

puts format_data(data, to_uppercase) # アウトプット: HELLO WORLD
puts format_data(data, to_lowercase) # アウトプット: hello world

5.2 ケース 2：Lambda をユースしたデータフィルタリング

特定のコンディションに基づいてデータをフィルタリングする必要があると仮定します。Lambda をユースしてフィルタリングロジックをディファインできます。

def filter_data(data, filter_criteria)
  data.select { |item| filter_criteria.call(item) }
end

numbers = [1, 2, 3, 4, 5, 6]
is_even = ->(x) { x % 2 == 0 }

even_numbers = filter_data(numbers, is_even)
puts even_numbers.inspect # アウトプット: [2, 4, 6]

5.3 ケース 3：& と Proc をコンバインしたメソッド・デリゲート

あるクラスがあり、メソッドのコールを内部のオブジェクトへ迅速にデリゲート（委譲）したいとイマジン（想像）してください。

class Logger
  def log(message)
    puts "ログのレコーディング: #{message}"
  end
end

class Service
  def initialize
    @logger = Logger.new
  end

  def log_message(&block) # コードブロックをレシーブする (自動的に Proc にコンバートされる)
    @logger.instance_eval &block # Logger インスタンスのコンテキストで該当コードブロックをエグゼキュートする
  end
end

service = Service.new
service.log_message { log("これはデリゲートされたメッセージです") } 
# アウトプット: ログのレコーディング: これはデリゲートされたメッセージです

このサンプルにおいて、Service クラス内の log_message メソッドはブロック（& を通じてインプリシットに Proc へコンバートされます）をレシーブします。その後、instance_eval を使用して @logger オブジェクトのコンテキスト内で該当ブロックをエグゼキュートし、実質的に log メソッドのコールを Logger インスタンスにデリゲートしています。