Rubyで複数のラムダを条件に応じて使い分ける方法

greeting = lambda { |name| "Hello, #{name}!" }
# または
greeting = ->(name) { "Hello, #{name}!" }

puts greeting.call("Alice")  # 出力: Hello, Alice!

morning_greeting = ->(name) { "Good morning, #{name}!" }
evening_greeting = ->(name) { "Good evening, #{name}!" }

time_of_day = "morning" # 条件によって変更される変数

greeting = if time_of_day == "morning"
             morning_greeting
           else
             evening_greeting
           end

puts greeting.call("Alice")  # 出力: Good morning, Alice!

greetings = {
  morning: ->(name) { "Good morning, #{name}!" },
  evening: ->(name) { "Good evening, #{name}!" },
  night: ->(name) { "Good night, #{name}!" }
}

time_of_day = :evening  # 条件に基づく選択

puts greetings[time_of_day].call("Alice")  # 出力: Good evening, Alice!

def choose_greeting(time_of_day)
  case time_of_day
  when "morning"
    ->(name) { "Good morning, #{name}!" }
  when "afternoon"
    ->(name) { "Good afternoon, #{name}!" }
  when "evening"
    ->(name) { "Good evening, #{name}!" }
  else
    ->(name) { "Hello, #{name}!" }
  end
end

greeting_lambda = choose_greeting("afternoon")
puts greeting_lambda.call("Alice")  # 出力: Good afternoon, Alice!

def choose_custom_greeting(time_of_day, weather)
  case [time_of_day, weather]
  when ["morning", "sunny"]
    ->(name) { "Good sunny morning, #{name}!" }
  when ["morning", "rainy"]
    ->(name) { "Stay dry, #{name}! Good morning!" }
  when ["evening", "clear"]
    ->(name) { "Have a peaceful evening, #{name}." }
  else
    ->(name) { "Hello, #{name}!" }
  end
end

greeting_lambda = choose_custom_greeting("morning", "rainy")
puts greeting_lambda.call("Alice")  # 出力: Stay dry, Alice! Good morning!

   lambda_example = ->(x) { x * 2 }
   proc_example = Proc.new { |x| x * 2 }

   puts lambda_example.call(5)    # 出力: 10
   # puts lambda_example.call      # エラー: wrong number of arguments
   puts proc_example.call         # 出力: nil (引数なしでもエラーは出ない)

   def lambda_vs_proc
     lambda_example = -> { return "Returned from lambda" }
     proc_example = Proc.new { return "Returned from proc" }

     puts lambda_example.call    # 出力: Returned from lambda
     puts proc_example.call      # メソッド全体が終了
     "This line will not be executed"
   end

   puts lambda_vs_proc  # 出力: Returned from proc

# 引数が正確である必要がある関数的な処理はラムダで定義
multiply = ->(x, y) { x * y }

# 柔軟に引数を扱いたい場合や、条件によってメソッド全体を終了させたい場合はProcを利用
stop_process = Proc.new { return "Process stopped due to error" }

def execute_process(value)
  return stop_process.call if value < 0
  multiply.call(value, 2)
end

puts execute_process(-1)  # 出力: Process stopped due to error
puts execute_process(5)   # 出力: 10

# 各役割ごとのメッセージを生成するラムダを定義
admin_message = ->(name) { "Welcome back, Administrator #{name}!" }
editor_message = ->(name) { "Hello, Editor #{name}. You can edit content." }
guest_message = ->(name) { "Welcome, Guest #{name}. Please sign up to get more access." }

# ラムダを役割ごとにハッシュに格納
role_messages = {
  admin: admin_message,
  editor: editor_message,
  guest: guest_message
}

# ユーザーの役割に応じたメッセージを生成するメソッド
def generate_message(role, name)
  message_lambda = role_messages[role.to_sym] || guest_message
  message_lambda.call(name)
end

# 例: 各役割でメッセージを生成
puts generate_message("admin", "Alice")   # 出力: Welcome back, Administrator Alice!
puts generate_message("editor", "Bob")    # 出力: Hello, Editor Bob. You can edit content.
puts generate_message("guest", "Charlie") # 出力: Welcome, Guest Charlie. Please sign up to get more access.
puts generate_message("unknown", "Dana")  # 出力: Welcome, Guest Dana. Please sign up to get more access.

# 数値の状態に応じたラムダを定義
positive_calculation = ->(num) { num * 2 }
negative_calculation = ->(num) { num + 5 }
zero_message = ->(_) { "The number is zero and cannot be processed." }

# 状態ごとにラムダを格納
calculations = {
  positive: positive_calculation,
  negative: negative_calculation,
  zero: zero_message
}

# 数値に応じた計算を行うメソッド
def calculate_based_on_value(num)
  case
  when num > 0
    calculations[:positive].call(num)
  when num < 0
    calculations[:negative].call(num)
  else
    calculations[:zero].call(num)
  end
end

# 例: 数値ごとの結果
puts calculate_based_on_value(10)   # 出力: 20
puts calculate_based_on_value(-3)   # 出力: 2
puts calculate_based_on_value(0)    # 出力: The number is zero and cannot be processed.

# 複数の処理を定義したラムダ
step1 = ->(num) { num + 10 }
step2 = ->(num) { num * 2 }
step3 = ->(num) { num - 5 }

# ラムダを順に格納した配列
pipeline = [step1, step2, step3]

# データを各ステップに渡して処理
def execute_pipeline(num, steps)
  steps.each { |step| num = step.call(num) }
  num
end

puts execute_pipeline(5, pipeline)  # 出力: 25

# 基本の操作を定義
addition = ->(num) { num + 3 }
multiplication = ->(num) { num * 4 }
subtraction = ->(num) { num - 2 }

# 条件に応じたラムダの選択
def choose_operations(include_addition, include_multiplication, include_subtraction)
  operations = []
  operations << addition if include_addition
  operations << multiplication if include_multiplication
  operations << subtraction if include_subtraction
  operations
end

# 選択されたラムダの組み合わせを適用
def apply_operations(num, operations)
  operations.each { |operation| num = operation.call(num) }
  num
end

# 設定に応じてラムダを選択し、実行
selected_operations = choose_operations(true, true, false)
puts apply_operations(10, selected_operations)  # 出力: 52

# ラムダの定義（依存関係を考慮）
initialize_step = -> { 10 }
increment_step = ->(num) { num + 15 }
multiply_step = ->(num) { num * 2 }

# 順序に従って実行する
def execute_dependent_flow(steps)
  result = steps.first.call  # 最初の初期化ラムダを実行
  steps[1..].each { |step| result = step.call(result) }  # 次のラムダを順に実行
  result
end

# 実行フロー
dependent_steps = [initialize_step, increment_step, multiply_step]
puts execute_dependent_flow(dependent_steps)  # 出力: 50

# エラーハンドリング付きのラムダ
safe_division = ->(x, y) do
  begin
    x / y
  rescue ZeroDivisionError
    "Error: Division by zero is not allowed."
  end
end

puts safe_division.call(10, 2)  # 出力: 5
puts safe_division.call(10, 0)  # 出力: Error: Division by zero is not allowed.

# エラー判定のあるラムダ
validate_positive = ->(num) { raise ArgumentError, "Number must be positive" if num < 0 }

def execute_with_error_handling(lambdas, value)
  lambdas.each do |lambda|
    begin
      lambda.call(value)
    rescue => e
      puts "Error encountered: #{e.message}"
      return
    end
  end
end

# 実行例
operations = [validate_positive, ->(num) { num * 2 }]
execute_with_error_handling(operations, -5)  # 出力: Error encountered: Number must be positive

# メインラムダと代替ラムダ
main_task = ->(num) { raise "Intentional error" if num < 10; num * 10 }
fallback_task = ->(num) { "Fallback: #{num} was too low for main task" }

def perform_task_with_fallback(task, fallback, value)
  begin
    task.call(value)
  rescue => e
    puts "Error encountered: #{e.message}. Executing fallback."
    fallback.call(value)
  end
end

# 実行例
puts perform_task_with_fallback(main_task, fallback_task, 5)  # 出力: Fallback: 5 was too low for main task
puts perform_task_with_fallback(main_task, fallback_task, 15) # 出力: 150

# 単一の責任を持つラムダの例
calculate_tax = ->(price) { price * 0.1 }
apply_discount = ->(price) { price - (price * 0.2) }

# 良い: 各ラムダは特定の目的に特化している
puts calculate_tax.call(100)     # 出力: 10.0
puts apply_discount.call(100)    # 出力: 80.0

# 条件ごとにラムダを格納したハッシュ
greeting_lambdas = {
  morning: ->(name) { "Good morning, #{name}!" },
  evening: ->(name) { "Good evening, #{name}!" }
}

# 条件に応じてラムダを呼び出す
def greet(time_of_day, name)
  greeting = greeting_lambdas[time_of_day]
  greeting ? greeting.call(name) : "Hello, #{name}!"
end

puts greet(:morning, "Alice")  # 出力: Good morning, Alice!
puts greet(:night, "Bob")      # 出力: Hello, Bob!

safe_divide = ->(x, y) do
  begin
    x / y
  rescue ZeroDivisionError
    "Error: Division by zero"
  end
end

puts safe_divide.call(10, 0)   # 出力: Error: Division by zero

calculate_vat = ->(price) { price * 0.2 }
apply_vat_discount = ->(price) { price * 0.8 }

# 意図が明確なラムダ名
puts calculate_vat.call(100)         # 出力: 20.0
puts apply_vat_discount.call(100)    # 出力: 80.0

# テスト対象のラムダ
capitalize_name = ->(name) { name.capitalize }

# テスト
puts capitalize_name.call("alice") == "Alice"  # 出力: true
puts capitalize_name.call("bob") == "Bob"      # 出力: true