コードを渡すということ

def process_data
  puts "処理を開始します。"
  # ここでブロックが実行される
  yield
  puts "処理を終了しました。"
end

process_data do
  puts "データ処理中です..."
end

#=> 処理を開始します。
#=> データ処理中です...
#=> 処理を終了しました。

def greet(name)
  # ブロックに'name'を渡す
  puts yield(name)
end

greet("Alice") do |n|
  "こんにちは、#{n}さん！"
end

#=> こんにちは、Aliceさん！

# ブロックをProcオブジェクトに変換して変数に格納
greeter = Proc.new do |name|
  "ようこそ、#{name}さん"
end

# callメソッドで実行
puts greeter.call("Bob")
#=> ようこそ、Bobさん

def proc_return_test
  my_proc = Proc.new { return "Procからreturnしました" }
  my_proc.call
  return "メソッドの最後です"
end

def lambda_return_test
  my_lambda = -> { return "Lambdaからreturnしました" }
  my_lambda.call
  return "メソッドの最後です"
end

puts proc_return_test    #=> Procからreturnしました
puts lambda_return_test  #=> メソッドの最後です

my_proc = Proc.new { |a, b| "Proc: a=#{a.inspect}, b=#{b.inspect}" }
my_lambda = ->(a, b) { "Lambda: a=#{a.inspect}, b=#{b.inspect}" }

puts my_proc.call(1)       #=> Proc: a=1, b=nil
puts my_lambda.call(1, 2)  #=> Lambda: a=1, b=2

# こちらはエラーになる
# puts my_lambda.call(1) #=> ArgumentError: wrong number of arguments

使い分けの基準: メソッドのように振る舞ってほしい場合はLambdaを、より柔軟なブロックとして使いたい場合はProcを選ぶのが一般的です。

def counter_generator
  count = 0
  # このProcは、変数`count`を記憶する
  Proc.new do
    count += 1
    puts "カウント: #{count}"
  end
end

# counterは`count`変数が0の状態を記憶している
counter = counter_generator

counter.call #=> カウント: 1
counter.call #=> カウント: 2

# 新しく作れば、また別の`count`が生まれる
new_counter = counter_generator
new_counter.call #=> カウント: 1

class Config
  attr_accessor :host, :port

  def setup(&block)
    # ブロック内の'self'をConfigインスタンス自身に変更して実行
    instance_eval(&block)
  end
end

config = Config.new
config.setup do
  # このブロックの中では self が config オブジェクトになる
  self.host = "localhost"
  self.port = 8080
end

puts "Host: #{config.host}, Port: #{config.port}"
#=> Host: localhost, Port: 8080

numbers = ["1", "2", "3"]

# 通常のブロック
integers = numbers.map { |s| s.to_i }
#=> [1, 2, 3]

# &演算子を使ったショートカット
integer_short = numbers.map(&:to_i)
#=> [1, 2, 3]

# 上の行は内部的に以下のように解釈される
# numbers.map { |s| s.send(:to_i) }