Rubyのlambdaで実現する柔軟な条件フィルタリングの実装法

my_lambda = lambda { |x| x * 2 }
puts my_lambda.call(10) # 出力: 20

my_proc = Proc.new { return "Procからのリターン" }
def test_proc
  my_proc.call
  "メソッドの最後"
end
puts test_proc # 出力: "Procからのリターン"

my_lambda = lambda { return "Lambdaからのリターン" }
def test_lambda
  my_lambda.call
  "メソッドの最後"
end
puts test_lambda # 出力: "メソッドの最後"

# 条件フィルタ用のlambdaを定義
is_even = lambda { |x| x.even? }
greater_than_five = lambda { |x| x > 5 }

# 条件に基づくフィルタリング
numbers = [1, 2, 6, 7, 8, 10]
filtered_numbers = numbers.select { |n| is_even.call(n) && greater_than_five.call(n) }

puts filtered_numbers # 出力: [6, 8, 10]

less_than_ten = lambda { |x| x < 10 }
filtered_numbers = numbers.select { |n| is_even.call(n) && greater_than_five.call(n) && less_than_ten.call(n) }

puts filtered_numbers # 出力: [6, 8]

users = [
  { name: "Alice", age: 25, gender: "female" },
  { name: "Bob", age: 20, gender: "male" },
  { name: "Carol", age: 17, gender: "female" },
  { name: "Dave", age: 30, gender: "male" }
]

# 条件フィルタ用のlambdaを定義
is_adult = lambda { |user| user[:age] >= 20 }
is_male = lambda { |user| user[:gender] == "male" }

# 条件に基づくフィルタリング
filtered_users = users.select { |user| is_adult.call(user) && is_male.call(user) }

puts filtered_users # 出力: [{:name=>"Bob", :age=>20, :gender=>"male"}, {:name=>"Dave", :age=>30, :gender=>"male"}]

products = [
  { name: "Laptop", price: 1500, in_stock: true },
  { name: "Tablet", price: 600, in_stock: false },
  { name: "Smartphone", price: 800, in_stock: true },
  { name: "Monitor", price: 300, in_stock: true }
]

# 条件フィルタ用のlambdaを定義
affordable = lambda { |product| product[:price] < 1000 }
in_stock = lambda { |product| product[:in_stock] }

# 条件に基づくフィルタリング
filtered_products = products.select { |product| affordable.call(product) && in_stock.call(product) }

puts filtered_products # 出力: [{:name=>"Smartphone", :price=>800, :in_stock=>true}, {:name=>"Monitor", :price=>300, :in_stock=>true}]

customers = [
  { name: "Alice", age: 28, location: "Tokyo", purchase_history: [200, 150] },
  { name: "Bob", age: 35, location: "Osaka", purchase_history: [500] },
  { name: "Carol", age: 22, location: "Tokyo", purchase_history: [] },
  { name: "Dave", age: 40, location: "Nagoya", purchase_history: [100, 400, 300] }
]

# 条件フィルタ用のlambdaを定義
is_adult = lambda { |customer| customer[:age] >= 30 }
lives_in_tokyo = lambda { |customer| customer[:location] == "Tokyo" }
has_recent_purchase = lambda { |customer| customer[:purchase_history].any? { |purchase| purchase > 100 } }

# 複数の条件に基づくフィルタリング
filtered_customers = customers.select do |customer|
  is_adult.call(customer) && lives_in_tokyo.call(customer) && has_recent_purchase.call(customer)
end

puts filtered_customers # 出力: []

products = [
  { name: "Laptop", price: 1500, in_stock: true },
  { name: "Tablet", price: 600, in_stock: false },
  { name: "Smartphone", price: 800, in_stock: true },
  { name: "Monitor", price: 300, in_stock: true }
]

# 動的に適用するフィルタ条件を定義
filter_conditions = [
  lambda { |product| product[:price] > 500 },
  lambda { |product| product[:in_stock] }
]

# 複数の条件を動的に適用
filtered_products = products.select do |product|
  filter_conditions.all? { |condition| condition.call(product) }
end

puts filtered_products # 出力: [{:name=>"Laptop", :price=>1500, :in_stock=>true}, {:name=>"Smartphone", :price=>800, :in_stock=>true}]

class Product
  attr_accessor :name, :price, :in_stock

  def initialize(name, price, in_stock)
    @name = name
    @price = price
    @in_stock = in_stock
  end

  # 条件フィルタのlambda定義
  HIGH_PRICE_FILTER = lambda { |product| product.price > 1000 }
  IN_STOCK_FILTER = lambda { |product| product.in_stock }

  # 条件に基づくフィルタリングメソッド
  def self.filter(products, *filters)
    products.select do |product|
      filters.all? { |filter| filter.call(product) }
    end
  end
end

# データとフィルタリングの実行
products = [
  Product.new("Laptop", 1500, true),
  Product.new("Tablet", 600, false),
  Product.new("Smartphone", 800, true),
  Product.new("Monitor", 300, true)
]

filtered_products = Product.filter(products, Product::HIGH_PRICE_FILTER, Product::IN_STOCK_FILTER)
filtered_products.each { |product| puts product.name } # 出力: "Laptop"

class Product
  attr_accessor :name, :price, :in_stock

  def initialize(name, price, in_stock)
    @name = name
    @price = price
    @in_stock = in_stock
    @custom_filters = []
  end

  # カスタムフィルタを追加する
  def add_filter(filter_lambda)
    @custom_filters << filter_lambda
  end

  # カスタムフィルタに基づいて判定
  def matches_custom_filters?
    @custom_filters.all? { |filter| filter.call(self) }
  end
end

product = Product.new("Laptop", 1500, true)
product.add_filter(lambda { |p| p.price > 1000 })
product.add_filter(lambda { |p| p.in_stock })

puts product.matches_custom_filters? # 出力: true

   my_lambda = lambda { |x, y| x + y }
   my_proc = Proc.new { |x, y| x + y }

   puts my_lambda.call(2) # エラー: wrong number of arguments (given 1, expected 2)
   puts my_proc.call(2)    # 出力: nil

   def lambda_test
     my_lambda = lambda { return "Lambdaからのリターン" }
     my_lambda.call
     "メソッドの最後"
   end

   def proc_test
     my_proc = Proc.new { return "Procからのリターン" }
     my_proc.call
     "メソッドの最後"
   end

   puts lambda_test # 出力: "メソッドの最後"
   puts proc_test   # 出力: "Procからのリターン"

   def with_block
     yield "Blockの実行"
   end

   def with_lambda(proc_object)
     proc_object.call("Lambdaの実行")
   end

   my_lambda = lambda { |msg| puts msg }
   with_block { |msg| puts msg } # 出力: Blockの実行
   with_lambda(my_lambda)         # 出力: Lambdaの実行

   name = "Alice"

   my_lambda = lambda { "Hello, #{name}" }
   def greet
     "Hello, world"
   end

   puts my_lambda.call # 出力: Hello, Alice
   puts greet          # 出力: Hello, world

products = [
  { name: "Laptop", price: 1500, in_stock: true },
  { name: "Tablet", price: 600, in_stock: false },
  { name: "Smartphone", price: 800, in_stock: true },
  { name: "Monitor", price: 300, in_stock: true }
]

# フィルタ用のlambdaを定義
price_range_filter = lambda { |product| product[:price] > 500 && product[:price] < 1000 }
in_stock_filter = lambda { |product| product[:in_stock] }

# フィルタリングの実行
filtered_products = products.select { |product| price_range_filter.call(product) && in_stock_filter.call(product) }
filtered_products.each { |product| puts product[:name] } # 出力: Smartphone

class ProductFilter
  def initialize(filters = [])
    @filters = filters
  end

  def apply(products)
    products.select do |product|
      @filters.all? { |filter| filter.call(product) }
    end
  end
end

products = [
  { name: "Laptop", price: 1500, in_stock: true },
  { name: "Tablet", price: 600, in_stock: false },
  { name: "Smartphone", price: 800, in_stock: true },
  { name: "Monitor", price: 300, in_stock: true }
]

# フィルタ条件を配列で指定
filters = [
  lambda { |product| product[:price] < 1000 },
  lambda { |product| product[:in_stock] }
]

product_filter = ProductFilter.new(filters)
filtered_products = product_filter.apply(products)
filtered_products.each { |product| puts product[:name] } # 出力: Smartphone, Monitor

class FlexibleFilter
  def initialize(and_filters = [], or_filters = [])
    @and_filters = and_filters
    @or_filters = or_filters
  end

  def apply(products)
    products.select do |product|
      @and_filters.all? { |filter| filter.call(product) } && 
      (@or_filters.empty? || @or_filters.any? { |filter| filter.call(product) })
    end
  end
end

products = [
  { name: "Laptop", price: 1500, in_stock: true },
  { name: "Tablet", price: 600, in_stock: false },
  { name: "Smartphone", price: 800, in_stock: true },
  { name: "Monitor", price: 300, in_stock: true }
]

# AND条件とOR条件を設定
and_filters = [lambda { |product| product[:price] > 500 }]
or_filters = [lambda { |product| product[:in_stock] }]

flexible_filter = FlexibleFilter.new(and_filters, or_filters)
filtered_products = flexible_filter.apply(products)
filtered_products.each { |product| puts product[:name] } # 出力: Laptop, Smartphone

users = [
  { name: "Alice", age: 22, email: "alice@example.com" },
  { name: "Bob", age: 17, email: nil },
  { name: "Carol", age: 25, email: "carol@example.com" },
  { name: "Dave", age: 16, email: "dave@example.com" }
]

# lambdaフィルタリング条件を作成
age_filter = lambda { |user| user[:age] >= 18 }
email_filter = lambda { |user| user[:email] != nil }

# フィルタリング実行
filtered_users = users.select { |user| age_filter.call(user) && email_filter.call(user) }

puts filtered_users # 期待される出力: AliceとCarolの情報のみ

products = [
  { name: "Laptop", price: 1500, in_stock: true },
  { name: "Tablet", price: 600, in_stock: false },
  { name: "Smartphone", price: 800, in_stock: true },
  { name: "Monitor", price: 300, in_stock: true }
]

# lambdaフィルタ条件の定義
price_filter = lambda { |product| product[:price] >= 800 }
stock_filter = lambda { |product| product[:in_stock] }

# フィルタ条件を配列に格納し、動的に適用
filters = [price_filter, stock_filter]

filtered_products = products.select do |product|
  filters.all? { |filter| filter.call(product) }
end

puts filtered_products # 期待される出力: LaptopとSmartphoneの情報のみ

users = [
  { name: "Alice", age: 22, email: "alice@example.com" },
  { name: "Bob", age: 17, email: nil },
  { name: "Carol", age: 25, email: "carol@example.com" },
  { name: "Dave", age: 16, email: "dave@example.com" }
]

# フィルタ条件を定義
age_range_filter = lambda { |user| user[:age] >= 20 && user[:age] < 30 }
email_present_filter = lambda { |user| user[:email] != nil }

# 複合条件に基づくフィルタリング
filtered_users = users.select do |user|
  age_range_filter.call(user) || email_present_filter.call(user)
end

puts filtered_users # 期待される出力: Alice、Carol、Daveの情報