Ruby Lambda #

my_lambda = lambda { |n| n * 2 }
my_lambda.call(5)

my_lambda = ->(n) { n * 2 }
my_lambda.call(5)

my_lambda = -> n { n * 2 }
my_lambda.call(5)

multi_line = ->(a, b) {
  result = a + b
  result * 2
}
multi_line.call(1, 2)

say_hello = -> { "Hello, World!" }
say_hello.call

say_hello = -> { puts "Hello" }
say_hello.call

greet = ->(name = "World") { "Hello, #{name}!" }
greet.call
greet.call("Ruby")

double = ->(n) { n * 2 }
double.call(5)

double = ->(n) { n * 2 }
double[5]

double = ->(n) { n * 2 }
double.(5)

is_even = ->(n) { n.even? }
is_even === 4
is_even === 5

case 4
when is_even then "偶数"
else "奇数"
end

my_lambda = ->(a, b) { a + b }
my_proc = Proc.new { |a, b| a + b }

my_lambda.call(1, 2)
my_lambda.call(1)
my_lambda.call(1, 2, 3)

my_proc.call(1, 2)
my_proc.call(1)
my_proc.call(1, 2, 3)

def test_lambda
  my_lambda = -> { return "lambda返回" }
  my_lambda.call
  "方法继续执行"
end

def test_proc
  my_proc = Proc.new { return "proc返回" }
  my_proc.call
  "这行不会执行"
end

test_lambda
test_proc

my_lambda = -> {}
my_proc = Proc.new {}

my_lambda.class
my_proc.class

my_lambda.lambda?
my_proc.lambda?

def create_counter
  count = 0
  -> { count += 1 }
end

counter = create_counter
counter.call
counter.call
counter.call

def create_pair
  value = 0
  [
    -> { value += 1 },
    -> { value -= 1 },
    -> { value }
  ]
end

inc, dec, get = create_pair
inc.call
inc.call
get.call
dec.call
get.call

def lazy_evaluation
  expensive_value = nil
  -> {
    expensive_value ||= calculate_expensive_value
  }
end

lazy = lazy_evaluation
lazy.call
lazy.call

def process(value, processor)
  processor.call(value)
end

double = ->(n) { n * 2 }
process(5, double)

process(5, ->(n) { n ** 2 })

def compose(f, g)
  ->(x) { f.call(g.call(x)) }
end

double = ->(n) { n * 2 }
increment = ->(n) { n + 1 }

double_then_increment = compose(increment, double)
double_then_increment.call(5)

increment_then_double = compose(double, increment)
increment_then_double.call(5)

def curry(f)
  ->(a) { ->(b) { f.call(a, b) } }
end

add = ->(a, b) { a + b }
curried_add = curry(add)

add_five = curried_add.call(5)
add_five.call(3)
add_five.call(10)

def create_filter(&condition)
  ->(items) { items.select(&condition) }
end

even_filter = create_filter(&:even?)
even_filter.call([1, 2, 3, 4, 5, 6])

positive_filter = create_filter { |n| n > 0 }
positive_filter.call([-1, 0, 1, 2, -3])

VALIDATORS = {
  email: ->(s) { s.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i) },
  phone: ->(s) { s.match?(/\A\d{11}\z/) },
  age: ->(n) { n.is_a?(Integer) && n >= 0 && n <= 150 }
}

def valid?(type, value)
  VALIDATORS[type].call(value)
end

valid?(:email, "user@example.com")
valid?(:phone, "12345678901")
valid?(:age, 30)

class EventHandler
  def initialize
    @handlers = {}
  end

  def on(event, &handler)
    @handlers[event] ||= []
    @handlers[event] << ->(*args) { handler.call(*args) }
  end

  def trigger(event, *args)
    @handlers[event]&.each { |h| h.call(*args) }
  end
end

handler = EventHandler.new
handler.on(:save) { |data| puts "Saving: #{data}" }
handler.on(:save) { |data| log("Saved: #{data}") }
handler.trigger(:save, { name: "Ruby" })

class LazyValue
  def initialize(&block)
    @block = block
    @computed = false
    @value = nil
  end

  def value
    unless @computed
      @value = @block.call
      @computed = true
    end
    @value
  end

  def computed?
    @computed
  end
end

lazy = LazyValue.new { expensive_computation }
lazy.computed?
lazy.value
lazy.computed?

class PriceCalculator
  STRATEGIES = {
    normal: ->(price) { price },
    discount: ->(price) { price * 0.9 },
    vip: ->(price) { price * 0.8 },
    sale: ->(price) { price * 0.5 }
  }

  def initialize(strategy = :normal)
    @strategy = STRATEGIES[strategy]
  end

  def calculate(price)
    @strategy.call(price)
  end
end

calculator = PriceCalculator.new(:vip)
calculator.calculate(100)

my_lambda = ->(x) { x * 2 }

my_proc = Proc.new { |x| x * 2 }

def with_callback(&callback)
  callback.call
end

double = ->(n) { n * 2 }

double = lambda { |n| n * 2 }

process = ->(input, options: {}) do
  transform(input, options)
end

process = ->(data, config) { transform(data, config) }