函数式 Ruby 编程

A: {}/do end # such as =[1,2,3].map{|x| x+1 }=
B: plus1 = lambda {|x| x + 1 }
C: plus1 = -> (x) { x + 1 }
D: plus1 = Proc.new { |x| x + 1 }

plus1 = ->(x) { x + 1 }

plus1 = ->(x) { x + 1 }
plus1.call(3)
plus1.(3)
plus1[3]

def plus1 x
  x + 1
end
[1,2,3,4].map &plus1

plus1 = ->(x) { x + 1 }
[1,2,3,4].map &plus1

def plus1 x
  x + 1
end
first_class_plus1 = method(:plus1)
[1,2,3,4].map &first_class_plus1

method(:plus1)
# => #<Method: Object#plus1>

class Method
  def to_proc
    lambda{|*args|
      self.call(*args)
    }
  end
end

%w(ouyang jichao).map &:capitalize 
# ===
%w(ouyang jichao).map { |x| x.capitalize}

%w(ouyang jichao).map &:capitalize.to_proc

%w(ouyang jichao).map &Proc.new(|x| x.send(:capitalize))

first, *middle_and_last = ['Phillip', 'Jay', 'Fry']
"first: #{first}, middle_and_last: #{middle_and_last}"

fry = {first: 'Phillip', middle: 'Jay', last: 'Fry'}
def printFirstName first:, **rest
  p first, rest
end
printFirstName fry

me = 'ouyang'
case me
when 'ouyang' 
  "hehe #{me}"
else 'hehe jichao'
end

class Me
  def initialize name
    @name = name
  end

  def heheda
    "呵呵哒 #{@name}"
  end
end

me = Me.new 'ouyang'

case me
when Me
  me.heheda
else
  '呵呵哒了'
end

require 'ostruct'
me = OpenStruct.new(name: 'jichao', first_name: 'ouyang')
case me
when ->(who){who.name=='jichao'}
  "hehe #{me}"
end

case 'jichao ouyang'
when /ouyang/
"呵呵哒"
end

if(/ouyang/ === 'jichao')
  "heheda"
end

opened_fridge = open_fridge
if opened_fridge
  fridge_w_elephent = put_elephent_in opened_fridge
  if fridge_w_elephent
    closed_fridge = close_fridge
    if closed_fridge
      'yay'
    else
      'fail to close fridge'
    end
  else
    'fail to put elephent in'
  end
else
  'fail to open fridge'
end

opened_fridge = open_fridge
if opened_fridge
  Monitoring.logger.info('fridge opened')
  fridge_w_elephent = put_elephent_in opened_fridge
  if fridge_w_elephent
    Monitoring.logger.info('puted a elephent into fridge')
    closed_fridge = close_fridge
    if closed_fridge
      Monitoring.logger.info('fridge closed')
      'yay'
    else
      Monitoring.logger.error('no able to close fridge')
      'fail to close fridge'
    end
  else
    Monitoring.logger.error('elephent put failed')
    'fail to put elephent in'
  end
else
  Monitoring.logger.error('fail to open fridge')
  'fail to open fridge'
end

begin
  close(put_elephent_in open_fridge)
rescue A=>e
 ...
rescue B=>e
 ...
rescue C=>e
 ...
end

require 'data.either'
Right.new(1).flat_map do |x| 
  if x < 1
    Left.new('meh')
  else
    Right.new(x+1)
  end
end
# => #<Right 2>

open_fridge.flat_map do |fridge|  # <= 1
  put_elephent_in fridge          # <= 2
end.flat_map do |fridge|
  close fridge                    # <= 3
end

def flat_map
  case self
  when Right
    yield @v
  else
    self
  end
end

do
  a <- fetchA
  b <- fetchB
  c <- put $ blah a ++ b

def fetch(endpoint, decoder)
  response = self.class.get(endpoint, format: :json)
  case response.code
  when 410
    Left.new(Exceptions::DataFailure.new("Resource #{endpoint} was deleted"))
  when 404
    Left.new(Exceptions::DataFailure.new("Resource #{endpoint} not exist"))
  when 200
    Right.new decoder.from_json(response.body)
  else
    Left.new(Exceptions::RepositoryError.new("Fetching #{endpoint} with Error:\n#{endpoint}, response code: #{response.code}"))
  end
end

failure_processed, success_processed = Either.partition Mapinator.run

Monitoring.send_processed success_processed.length
Monitoring.logger.info("Processed successful #{success_processed.length} listings: #{success_processed}")
Monitoring.logger.error("Processed FAILURE #{failure_processed.length} with Exceptions:") unless failure_processed.empty?
...

require "celluloid/autostart"

module Enumerable
  def pmap(&block)
    futures = map { |elem| Celluloid::Future.new(elem, &block) }
    futures.map(&:value)
  end
end