来看个诡异的，下面这段代码我们可能会期望是返回一个数组，只是 jichao 会变成 lulu 而已

%w(ouyang jichao).map { |x| return 'lulu' if x == 'jichao'; x}

"lulu"

显然 return 之后的代码就再也走不到了，整个map会直接返回

但是如果你用 lambda 而不是普通 Proc，你会发现

%w(ouyang jichao).map &->(x){ return 'lulu' if x == 'jichao'; x}

["ouyang", "lulu"]

嗒哒，输出我们的期望了，lambda 的表现跟一个普通函数是一样的，函数的 return 当然不会导致调用者的返回。

确切的说是参数元数 arity 的检查，比如随便定义一个method，如果你给的参数元数不匹配，会得到一个异常

def heheda who
  "heheda #{who}"
end
heheda

`heheda': wrong number of arguments (0 for 1) (ArgumentError)

因为定义的是一元的函数，调用时并没有给任何参数，就挂了

但是 Proc 是不会管这个的

heheda = Proc.new{|who| p "heheda #{who}"}
heheda.()

"heheda "

Proc 完全不会理会参数，如果binding能找到，就用了，如果没有，也继续运行。

lambda，则更像一个method

heheda = lambda {|who| p "heheda #{who}"}
heheda.()

`block in main': wrong number of arguments (0 for 1) (ArgumentError)

first, *middle_and_last = ['Phillip', 'Jay', 'Fry']
p first, middle_and_last

destructuring 一个数组如此简单，但是hash就不这么容易，好在，方法的参数会自带 destructure的功能：

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

这玩意 ruby 叫它 keyword arguments, first: 会匹配 fry 中的 first 并将值绑定到 first ， **rest 绑定剩下的所有东西。

数组也可以这样搞：

1: fry = ['Phillip', 'Jay', 'Fry']
2: def printFirstName first, *rest
3: p first, rest
4: end
5: printFirstName *fry

要注意第5行, 调用时记得给数组加 *, 这样解释器才知道不是把整个 fry 扔给 printFirstName 当参数，而是把 fry 的内容扔过去当参数。

ruby 中的 case http://docs.ruby-lang.org/en/2.2.0/syntax/control_expressions_rdoc.html#label-case+Expression 可以搞定四种模式匹配

lambda （aka guard）

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

hehe #<OpenStruct name="jichao", first_name="ouyang">

正则

case 'jichao ouyang'
when /ouyang/
"heheda"
end

heheda

其实只是个简单的语法糖

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

创建一个刚好够用的 Either 非常简单

Functor

module Either
  def initialize v
    @v = v
  end

  def map
    case self
    when Right
      Right.new(yield @v)
    else
      self
    end
  end
  alias :fmap :map

Monad

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

alias :chain :bind
alias :flat_map :bind

一个好看的 inspect

  def inspect
    case self
    when Left
      "#<Left value=#{@v}>"
    else
      "#<Right value=#{@v}>"
    end
  end
end

联合类型 Left | Right

class Left
  include Either
  def initialize v=nil
    @v=v
  end

  def == other
    case other
    when Left
      other.left_map { |v| return v == @v }
    else
      false
    end
  end
end

class Right
  include Either
  def == other
    case other
    when Right
      other.map { |v| return v == @v }
    else
      false
    end
  end
end

1: def run
2:   list_of_error_or_detail =
3:     listof_error_or_id.map do |error_or_id| # <-
4:     error_or_id.flat_map do |id| # <-
5:       error_or_detail_of(id) # <-
6:     end
7:   end
8:   list_of_error_or_detail.map { |error_or_detail| error_or_saved error_or_detail} # <-
9: end

1. listof_error_or_id 是一个 IO, 去某个地方拿一串 id, 或者返回一串错误, 所以类型是 [Either error id]
2. 所以 error_or_id 的类型是 Either error id, flat_map 可以把 id 取出来, 如果有的话
3. 取出来的 id 交给 error_or_detail_of, 该函数也是 IO, 复杂获得对应 id 的 详细信息, 是IO就有可能会有错误, 所以返回值类型也是 Either error detail
4. 这时, 如果是用 fmap 转换完成后会变成一个 Either error (Either error detail). 但显然我们不需要嵌套这么多层, flat 一些会变成 Either error detail
5. 后面的 save 函数也是类似的 IO 操作, 返回 Either error saved

那么我们的业务逻辑的流程走完了，该负责监控的逻辑了，注意现在 run 的返回值类型是 Either[Error, [Either[Error, Data]]]

failures, success = run.partition {|lr| !lr.is_a? Right}
error_msg = failures.map do |failure|
  failure.left_map &:message
end.join "\n"
logger.error "processing failure #{failues.length}:\n#{error_msg}" unless error_msg.blank?
logger.info "processing success #{success.length}: #{success}"

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

你懂的，把我们feeder的 map 都换成 pmap ,多线程就这么简单