Chaining Either for Ruby

either.rb

# A chainable Either monad for Ruby
#
# Examples
#
#  Either.right('s') >> proc { |s| Either.right(s + '-1') } >> proc { |s| Either.right(s + '-2') }
#  #=> #<Either @left=nil, @right="s-1-2">
#
#  Either.right('s') >> proc { |s| Either.left('error!') } >> proc { |s| Either.right(s + '-2') }
#  #=> #<Either @left='error!', @right=nil>
#
# Returns either left or right.
class Either
  attr_reader :left, :right
  private_class_method :new

  def initialize(left, right)
    @left = left
    @right = right
  end

  def left?
    !!left
  end

  def right?
    not left?
  end

  def >>(callable)
    if left?
      self
    else
      callable.call(right).tap do |e|
        fail "No quantum leaps allowed! Expected Either; got #{e.inspect}" unless e.is_a?(Either)
      end
    end
  end

  # Short-circuit applicative AND
  #
  # Examples
  #
  #   Either.right(1) & Either.right(2) & Either.right(3)
  #   #=> #<Either: @left=nil, @right=3>
  #
  #   Either.right(1) & Either.left(2) & Either.right(3)
  #   #=> #<Either: @left=2, @right=nil>
  #
  # Returns either the first Left or the last Right
  def &(other)
    fail "Expected Either; got #{other.inspect}" unless other.is_a?(Either)
    if left?
      self
    else
      other
    end
  end

  def self.left(left)
    new(left, nil)
  end

  def self.right(right)
    new(nil, right)
  end

end

examples.rb

def controller
  
  res = ParseParam.call(params)
  res = res >> lambda { |res| DoSomeStuff.call(res) }
  res = res >> lambda { |res| FinickyThirdParty.call(res) }
  res = res >> ...
  res.to_xml

end

# If this seems like a good idea, we can add a little bit of sugar:

res = Either.right('ok')
res >>= JustAnotherProc

In this spirit I just came up with this https://github.com/pzol/deterministic (still work in progress)