NOTICE: Re-thinking is happening...
Scala has evolved quite a bit since this project began in 2011, and mainstream Ruby usage has evolved as well.
In the branch experimental-0.5, new things are going to be tried.
If you're interested in sharing your ideas, join the mailing list.
Rumonade
Project: github
Documentation: rubydoc.info
A Ruby Monad Library, Inspired by Scala
Are you working in both the Scala and Ruby worlds, and finding that you miss some of the practical benefits of Scala's monads in Ruby? If so, then Rumonade is for you.
The goal of this library is to make the most common and useful Scala monadic idioms available in Ruby via the following classes:
Syntactic support for scala-like for-comprehensions will be implemented
as a sequence of calls to flat_map
, select
, etc, modeling Scala's
approach.
Support for an all_catch idiom will be implemented to turn blocks which might throw exceptions into Option or Either results. If this proves useful (and a good fit for Ruby), then more narrow functional catchers can be implemented as well.
Usage Examples
Option: handle possibly nil values in a functional fashion:
def format_date_in_march(time_or_date_or_nil)
Option(time_or_date_or_nil). # wraps possibly-nil value in an Option monad (Some or None)
map(&:to_date). # transforms a contained Time value into a Date value
select {|d| d.month == 3}. # filters out non-matching Date values (Some becomes None)
map(&:to_s). # transforms a contained Date value into a String value
map {|s| s.gsub('-', '')}. # transforms a contained String value by removing '-'
get_or_else("not in march!") # returns the contained value, or the alternative if None
end
format_date_in_march(nil) # => "not in march!"
format_date_in_march(Time.parse('2009-01-01 01:02')) # => "not in march!"
format_date_in_march(Time.parse('2011-03-21 12:34')) # => "20110321"
Note:
- each step of the chained computations above are functionally isolated
- the value can notionally start as nil, or become nil during a computation, without effecting any other chained computations
Either: handle failures (Left) and successes (Right) in a functional fashion:
def find_person(name)
case name
when /Jack/i, /John/i
Right(name.capitalize)
else
Left("No such person: #{name.capitalize}")
end
end
# success looks like this:
find_person("Jack")
# => Right("Jack")
# failure looks like this:
find_person("Jill")
# => Left("No such person: Jill")
# lift the contained values into Array, in order to combine them:
find_person("Joan").lift_to_a
# => Left(["No such person: Joan"])
# on the 'happy path', combine and transform successes into a single success result:
(find_person("Jack").lift_to_a +
find_person("John").lift_to_a).right.map { |*names| names.join(" and ") }
# => Right("Jack and John")
# but if there were errors, we still have a Left with all the errors inside:
(find_person("Jack").lift_to_a +
find_person("John").lift_to_a +
find_person("Jill").lift_to_a +
find_person("Joan").lift_to_a).right.map { |*names| names.join(" and ") }
# => Left(["No such person: Jill", "No such person: Joan"])
# equivalent to the previous example, but shorter:
%w(Jack John Jill Joan).
map { |nm| find_person(nm).lift_to_a }.inject(:+).
right.map { |*names| names.join(" and ") }
# => Left(["No such person: Jill", "No such person: Joan"])
Also, see the Either
class in action in the Ruby version
of A Tale of Three Nightclubs
validation example in F#, and compare it to the Scala version using scalaz.
Hash: flat_map
returns a Hash for each key/value pair; get
returns an Option
h = { "Foo" => 1, "Bar" => 2, "Baz" => 3 }
h = h.flat_map { |k, v| { k => v, k.upcase => v * 10 } }
# => {"Foo"=>1, "FOO"=>10, "Bar"=>2, "BAR"=>20, "Baz"=>3, "BAZ"=>30}
h = h.select { |k, v| k =~ /^b/i }
# => {"Bar"=>2, "BAR"=>20, "Baz"=>3, "BAZ"=>30}
h.get("Bar")
# => Some(2)
h.get("Foo")
# => None
Approach
There have been many posts and discussions about monads in Ruby, which have sparked a number of approaches.
Rumonade wants to be a practical drop-in Monad solution that will fit well into the Ruby world.
The priorities for Rumonade are:
- Practical usability in day-to-day Ruby
- don't mess up normal idioms of the language (e.g.,
Hash#map
) - don't slow down normal idioms of the language (e.g.,
Array#map
)
- don't mess up normal idioms of the language (e.g.,
- Rubyish-ness of usage
- Monad is a mix-in, requiring methods
self.unit
and#bind
be implemented by target class - Prefer blocks to lambda/Procs where possible, but allow both
- Monad is a mix-in, requiring methods
- Equivalent idioms to Scala where possible
Status
Option, Either, Array, and Hash are already usable.
Supported Ruby versions: MRI 2.0.0, 1.9.3, 1.9.2, JRuby in 1.9 mode, and Rubinius in 1.9 mode.
Please try it out, and let me know what you think! Suggestions are always welcome.