monadic 0.0.5 → 0.0.6

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.2 
+  - 1.9.3
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode
+notifications:
+  irc: "irc.freenode.org#anixe"

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v0.0.6
+**Contains Breaking Changes**
+
+Refactoring to use internal `Monad` class, from which all monads inherit.
+
+Reimplemented `Maybe` as inherited class from `Monad`. The old `Option` implementation has been removed, maybe does the same though, but the code is much cleaner and obeys the 3 monadic laws.
+
+Removed `Maybe#fetch` call with block`
+
+`Either` and `Validation` are now in the `Monadic` namespace.
+
+Added Travis-Ci integration, [![Build Status](https://secure.travis-ci.org/pzol/monadic.png?branch=master)](http://travis-ci.org/pzol/monadic)
+
+
 ## v0.0.5 
 
 Removed the `#chain` method alias for bind in `Either`.

data/README.md

@@ -1,25 +1,23 @@
 # Monadic
 
-helps dealing with exceptional situations, it comes from the sphere of functional programming and bringing the goodies I have come to love in [Scala](http://www.scala-lang.org/) to my ruby projects (hence I will be using more [Scala](http://www.scala-lang.org/) like constructs than Haskell).
+helps dealing with exceptional situations, it comes from the sphere of functional programming and bringing the goodies I have come to love in [Scala](http://www.scala-lang.org/) and [Haskell](http://www.haskell.org/) to my ruby projects.
 
 My motivation to create this gem was that I often work with nested Hashes and need to reach deeply inside of them so my code is sprinkled with things like some_hash.fetch(:one, {}).fetch(:two, {}).fetch(:three, "unknown"). 
 
 We have the following monadics (monads, functors, applicatives and variations):
 
-- Option (Maybe in Haskell) - [Scala](http://www.scala-lang.org/) like with a rubyesque flavour
-- Either - more Haskell like
-- Validation 
+- Maybe  - use if you have __one__  exception
+- Either - use if you have __many__ exceptions, and one call depends on the previous
+- Validation - use if you have __many__ independent calls (usually to validate an object)
 
 What's the point of using monads in ruby? To me it started with having a safe way to deal with nil objects and other exceptions.
-Thus you contain the erroneous behaviour within a monad - an indivisible, impenetrable unit.
-
-Monad purists might complain that there is no unit method to get the zero monad, I didn't include them, as I didn't find this idiomatic to the ruby language. I prefer to focus on the pragmatic uses of monads. If you want to learn moar about monads, see the references section at the bottom.  
-
+Thus you contain the erroneous behaviour within a monad - an indivisible, impenetrable unit. Functional programming considers _throwing_ exceptions to be a side-effect, instead we _propagate_ exceptions, i.e. return them as a result of a function call.
+ 
 A monad is most effectively described as a computation that eventually returns a value. -- Wolfgang De Meuter
 
 ## Usage
 
-### Option
+### Maybe
 Is an optional type, which helps to handle error conditions gracefully. The one thing to remember about option is: 'What goes into the Option, stays in the Option'. 
 
     Option(User.find(123)).name._         # ._ is a shortcut for .fetch 
@@ -28,57 +26,51 @@ Is an optional type, which helps to handle error conditions gracefully. The one
     Maybe(User.find(123)).name._
 
     # confidently diving into nested hashes
-    Maybe({})[:a][:b][:c]                   == None
-    Maybe({})[:a][:b][:c].fetch('unknown')  == None
+    Maybe({})[:a][:b][:c]                   == Nothing
+    Maybe({})[:a][:b][:c].fetch('unknown')  == "unknown"
     Maybe(a: 1)[:a]._                       == 1
 
 Basic usage examples:
 
     # handling nil (None serves as NullObject)
-    obj = nil
-    Option(obj).a.b.c            == None
-
-    # None stays None
-    Option(nil)._                == "None"
-    "#{Option(nil)}"             == "None"
-    Option(nil)._("unknown")     == "unknown"
-    Option(nil).empty?           == true
-    Option(nil).truly?           == false
-
-    # Some stays Some, unless you unbox it
-    Option('FOO').downcase       == Some('foo') 
-    Option('FOO').downcase.fetch == "foo"
-    Option('FOO').downcase._     == "foo"
-    Option('foo').empty?         == false
-    Option('foo').truly?         == true
+    Maybe(nil).a.b.c            == Nothing
+
+    # Nothing
+    Maybe(nil)._                == Nothing
+    "#{Maybe(nil)}"             == "Nothing"
+    Maybe(nil)._("unknown")     == "unknown"
+    Maybe(nil).empty?           == true
+    Maybe(nil).truly?           == false
+
+    # Just stays Just, unless you unbox it
+    Maybe('FOO').downcase       == Just('foo') 
+    Maybe('FOO').downcase.fetch == "foo"          # unboxing the value
+    Maybe('FOO').downcase._     == "foo"          
+    Maybe('foo').empty?         == false          # always non-empty
+    Maybe('foo').truly?         == true           # depends on the boxed value
+    Maybe(false).empty?         == false
+    Maybe(false).truly?         == false
 
 Map, select:
     
-    Option(123).map   { |value| User.find(value) } == Option(someUser)    # if user found
-    Option(0).map     { |value| User.find(value) } == None                # if user not found
-    Option([1,2]).map { |value| value.to_s }       == Option(["1", "2"])  # for all Enumerables
+    Maybe(123).map   { |value| User.find(value) } == Just(someUser)      # if user found
+    Maybe(0).map     { |value| User.find(value) } == Nothing             # if user not found
+    Maybe([1,2]).map { |value| value.to_s }       == Just(["1", "2"])    # for all Enumerables
 
-    Option('foo').select { |value| value.start_with?('f') } == Some('foo')
-    Option('bar').select { |value| value.start_with?('f') } == None
+    Maybe('foo').select { |value| value.start_with?('f') } == Just('foo')
+    Maybe('bar').select { |value| value.start_with?('f') } == Nothing
 
 Treat it like an array:
 
-    Option(123).to_a         == [123]
-    Option([123, 456]).to_a  == [123, 456]
-    Option(nil)              == []
+    Maybe(123).to_a          == [123]
+    Maybe([123, 456]).to_a   == [123, 456]
+    Maybe(nil).to_a          == []
 
 Falsey values (kind-of) examples:
 
-    user = Option(User.find(123))
+    user = Maybe(User.find(123))
     user.name._
 
-    user.fetch('You are not logged in') { |user| "You are logged in as #{user.name}" }.should == 'You are logged in as foo'
-
-    if user != nil
-      "You are logged in as foo"
-    else
-      "You are not logged in"
-
     user.subscribed?              # always true
     user.subscribed?.truly?       # true if subscribed is true
     user.subscribed?.fetch(false) # same as above
@@ -105,7 +97,7 @@ Slug example
 
     # do it with a default
     def slug(title)
-      Option(title).strip.downcase.tr_s('^[a-z0-9]', '-')._('unknown-title')
+      Maybe(title).strip.downcase.tr_s('^[a-z0-9]', '-')._('unknown-title')
     end
 
 ### Either
@@ -244,6 +236,11 @@ Or install it yourself as:
 
     $ gem install monadic
 
+## Compatibility
+Monadic is tested under ruby MRI 1.9.2, 1.9.3, jruby 1.9 mode, rbx 1.9 mode.
+
+See the build status [![Build Status](https://secure.travis-ci.org/pzol/monadic.png?branch=master)](http://travis-ci.org/pzol/monadic) 
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -1,2 +1,11 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = FileList['spec/**/*_spec.rb']
+  t.rspec_opts = %w[--format doc --color]
+end
+
+task :default => :spec

data/lib/monadic/either.rb

@@ -1,93 +1,108 @@
-# Chain various method calls
-module Either
-  def self.chain(initial=nil, &block)
-    Either::Chain.new(&block).call(initial)
-  end
+module Monadic
+  # @abstract Chains function calls and stops executing if one of them fails.
+  class Either < Monad
+    def self.chain(initial=nil, &block)
+      Either::Chain.new(&block).call(initial)
+    end
 
-  def success?
-    is_a? Success
-  end
+    def self.unit(value)
+      return Failure.new(value) if value.nil? || (value.respond_to?(:empty?) && value.empty?) || !value
+      return Success.new(value)
+    end
 
-  def failure?
-    is_a? Failure
-  end
+    # Initialize is private, because it always would return an instance of Either, but Success or Failure 
+    # are required (Either is abstract).
+    def initialize(value)
+      raise NoMethodError, "private method `new' called for #{self.class.name}, use `unit' instead"
+    end
 
-  def fetch(default=@value)
-    return default if failure?
-    return @value
-  end
-  alias :_     :fetch
-
-  def bind(proc=nil, &block)
-    return self if failure?
-
-    begin
-      result = if proc && proc.arity == 0 
-                 then proc.call
-                 else (proc || block).call(@value) 
-               end
-      result ||= Failure(nil)
-      result = Either(result) unless result.is_a? Either
-      result    
-    rescue Exception => ex
-      Failure(ex)      
+    def success?
+      is_a? Success
     end
-  end
-  alias :>=  :bind
-  alias :+   :bind
 
-  def to_s
-    "#{self.class.name}(#{@value.nil? ? 'nil' : @value.to_s})"
-  end
+    def failure?
+      is_a? Failure
+    end
 
-  def ==(other)
-    return false unless self.class === other
-    return other.fetch == @value
+    def fetch(default=@value)
+      return default if failure?
+      return @value
+    end
+    alias :_     :fetch
+
+    def bind(proc=nil, &block)
+      return self if failure?
+
+      begin
+        result = if proc && proc.arity == 0 
+                   then proc.call
+                   else (proc || block).call(@value) 
+                 end
+        result ||= Failure(nil)
+        result = Either(result) unless result.is_a? Either
+        result    
+      rescue Exception => ex
+        Failure(ex)      
+      end
+    end
+    alias :>=  :bind
+    alias :+   :bind
   end
 
-end
+  class Either::Chain
+    def initialize(&block)
+      @chain = []
+      instance_eval(&block)
+    end
 
-class Either::Chain
-  def initialize(&block)
-    @chain = []
-    instance_eval(&block)
-  end
+    def call(initial)
+      @chain.inject(Success(initial)) do |result, current|
+        result.bind(current)
+      end
+    end
 
-  def call(initial)
-    @chain.inject(Success(initial)) do |result, current|
-      result.bind(current)
+    def bind(proc=nil, &block)
+      @chain << (proc || block)
     end
   end
 
-  def bind(proc=nil, &block)
-    @chain << (proc || block)
+  # @private instance and class methods for Success and Failure
+  module SuccessFailure
+    module ClassMethods
+      def unit(value)
+        new(value)
+      end
+    end
+    module InstanceMethods
+      def initialize(value)
+        @value = join(value)
+      end 
+    end
   end
 
-end
-
-class Success 
-  include Either
-  def initialize(value)
-    @value = value
+  class Success < Either
+    extend  SuccessFailure::ClassMethods
+    include SuccessFailure::InstanceMethods
   end
-end
 
-class Failure 
-  include Either
-  def initialize(value)
-    @value = value
+  class Failure < Either
+    extend  SuccessFailure::ClassMethods
+    include SuccessFailure::InstanceMethods
   end
-end
 
-def Success(value)
-  Success.new(value)
-end
+  def Failure(value)
+    Failure.new(value)
+  end
 
-def Failure(value)
-  Failure.new(value)
-end
+  # Factory method 
+  # @return [Success]
+  def Success(value)
+    Success.new(value)
+  end
 
-def Either(value)
-  return Failure(value) if value.nil? || (value.respond_to?(:empty?) && value.empty?) || !value
-  return Success(value)
+  # Magic factory
+  # @return [Success, Failure] depending whether +value+ is falsey
+  def Either(value)
+    Either.unit(value)
+  end
 end

data/lib/monadic/maybe.rb

@@ -0,0 +1,92 @@
+module Monadic
+  # @api private helps treating `Maybe` like Either in Scala
+  module ScalaStuff
+    def map(proc = nil, &block)
+      return Maybe(@value.map(&block)) if @value.is_a?(Enumerable)
+      return Maybe((proc || block).call(@value))
+    end
+
+    def select(proc = nil, &block)
+      return Maybe(@value.select(&block)) if @value.is_a?(Enumerable)
+      return Nothing unless (proc || block).call(@value)
+      return self
+    end
+  end
+
+  class Maybe < Monad
+    include ScalaStuff
+
+    def self.unit(value)
+      return Nothing if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      return Just.new(value)
+    end
+
+    # Initialize is private, because it always would return an instance of Maybe, but Just or Nothing 
+    # are required (Maybe is abstract).
+    def initialize(*args)
+      raise NoMethodError, "private method `new' called for #{self.class.name}, use `unit' instead"
+    end
+
+    def empty?
+      @value.respond_to?(:empty?) && @value.empty?
+    end
+
+    def to_ary
+      return [@value].flatten if @value.respond_to? :flatten
+      return [@value]
+    end
+    alias :to_a :to_ary
+
+    def truly?
+      @value == true
+    end
+  end
+
+  class Just < Maybe
+    def initialize(value)
+      @value = join(value)
+    end
+
+    def fetch(default=nil)
+      @value
+    end
+    alias :_ :fetch
+
+    def method_missing(m, *args)
+      Maybe(@value.__send__(m, *args))
+    end
+  end
+
+  class Nothing < Maybe
+    class << self
+      def fetch(default=nil)
+        return self if default.nil?
+        return default
+      end
+      alias :_ :fetch
+
+      def method_missing(m, *args)
+        self
+      end
+
+      def to_ary
+        []
+      end
+      alias :to_a :to_ary
+
+      def to_s
+        'Nothing'
+      end
+
+      def truly?
+        false
+      end
+    end
+  end
+
+  def Maybe(value)
+    Maybe.unit(value)
+  end
+  alias :Just     :Maybe
+  alias :Nothing  :Maybe
+end

data/lib/monadic/monad.rb

@@ -0,0 +1,38 @@
+module Monadic 
+  class Monad
+    def self.unit(value)
+      new(value)
+    end
+
+    def initialize(value)
+      @value = join(value)
+    end
+
+    def bind(proc=nil, &block)
+      (proc || block).call(@value)
+    end
+
+    # If the passed value is monad already, get the value to avoid nesting
+    # M[M[A]] is equivalent to M[A]
+    def join(value)
+      if value.is_a? self.class then value.fetch
+      else value end
+    end
+
+    # Unwraps the the Monad
+    def fetch
+      @value
+    end
+    alias :_ :fetch
+
+    def to_s
+      pretty_class_name = self.class.name.split('::')[-1]
+      "#{pretty_class_name}(#{@value.nil? ? 'nil' : @value.to_s})"
+    end
+
+    def ==(other)
+      return false unless other.is_a? self.class
+      @value == other.instance_variable_get(:@value)
+    end
+  end
+end

data/lib/monadic/validation.rb

@@ -1,24 +1,28 @@
-def Validation(&block)
-  Validation.new.call(&block)
-end
-
-# Conducts several function calls which do checks, of which each must return Success or Failure
-# and returns a list of all failures. 
-# Validation is not a monad, but an deemed an applicative functor
-class Validation
-  def initialize
-    @result = Success([])
+module Monadic
+  # Wraps the construction of the Validation class
+  def Validation(&block)
+    Validation.new.call(&block)
   end
 
-  def call(&block)
-    instance_eval(&block)
-  end
+  # Conducts several function calls which do checks, of which each must return Success or Failure
+  # and returns a list of all failures. 
+  # Validation is not a monad, but an deemed an applicative functor
+  class Validation
+    def initialize
+      @result = Success([])
+    end
+
+    def call(&block)
+      instance_eval(&block)
+    end
 
-  def check(proc=nil, &block)
-    result = (proc || block).call
-    raise NotEitherError, "Expected #{result.inspect} to be an Either" unless result.is_a? Either
-    @result = Failure(@result.fetch << result.fetch) if result.failure?
+    # 
+    def check(proc=nil, &block)
+      result = (proc || block).call
+      raise NotEitherError, "Expected #{result.inspect} to be an Either" unless result.is_a? Either
+      @result = Failure(@result.fetch << result.fetch) if result.failure?
 
-    @result
+      @result
+    end
   end
 end

data/lib/monadic/version.rb

@@ -1,3 +1,3 @@
 module Monadic
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/lib/monadic.rb

@@ -1,7 +1,8 @@
 require 'monadic/version'
 
 require 'monadic/errors'
-require 'monadic/option'
+require 'monadic/monad'
+require 'monadic/maybe'
 require 'monadic/either'
 require 'monadic/validation'
 
@@ -9,5 +10,3 @@ module Monadic
 end
 
 include Monadic
-None = Monadic::None
-Some = Monadic::Some

data/monadic.gemspec

@@ -4,7 +4,7 @@ require File.expand_path('../lib/monadic/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Piotr Zolnierek"]
   gem.email         = ["pz@anixe.pl"]
-  gem.description   = %q{brings some functional goodness to ruby}
+  gem.description   = %q{brings some functional goodness to ruby by giving you some monads}
   gem.summary       = %q{see README}
   gem.homepage      = "http://github.com/pzol/monadic"
 
@@ -21,4 +21,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'guard-bundler'
   gem.add_development_dependency 'growl'
   gem.add_development_dependency 'activesupport'
+  gem.add_development_dependency 'rake'
 end

data/spec/either_spec.rb

@@ -1,14 +1,34 @@
 require 'spec_helper'
 
-describe 'Either' do
+describe Monadic::Either do
+  it 'Either cannot be created using #new, use #unit instead' do
+    expect { Either.new(1) }.to raise_error NoMethodError
+  end
+
+  it 'Success.new and Success.unit and Success() return the same' do
+    Success(1).should == Success.unit(1)
+    Success.new(1).should == Success.unit(1)
+
+    Success(nil).should == Success.unit(nil)
+    Success.new(nil).should == Success.unit(nil)
+  end
+
+  it 'Failure.new and Failure.unit and Failure() return the same' do
+    Failure(1).should == Failure.unit(1)
+    Failure.new(1).should == Failure.unit(1)
+    
+    Failure(nil).should == Failure.unit(nil)
+    Failure.new(nil).should == Failure.unit(nil)
+  end
+
   it 'Success and Failure should be kind of Either' do
-    Success.new(0).should be_kind_of(Either)
-    Failure.new(0).should be_kind_of(Either)
+    Success.unit(0).should be_kind_of(Either)
+    Failure.unit(0).should be_kind_of(Either)
   end
 
   it '#to_s works' do
-    Success.new("it worked!").to_s.should == "Success(it worked!)"
-    Failure.new(nil).to_s.should == "Failure(nil)"
+    Success.unit("it worked!").to_s.should == "Success(it worked!)"
+    Failure.unit(nil).to_s.should == "Failure(nil)"
   end
 
   it 'allows to verify equality' do
@@ -190,7 +210,7 @@ describe 'Either' do
               bind {|path|    load_file(path)          }.
               bind {|content| process_content(content) }
     either.should be_a_failure
-    KeyError.should === either.fetch
+    either.fetch.should be_a KeyError
   end
 
   it 'instance variables' do

data/spec/jruby_fixes.rb

@@ -0,0 +1,3 @@
+if defined?(JRUBY_VERSION) && RUBY_VERSION =~ /^1\.9/
+  KeyError = IndexError
+end

data/spec/maybe_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe Monadic::Maybe do
+  it_behaves_like 'a Monad' do
+    let(:monad) { Maybe }
+  end
+
+  it 'Maybe cannot be created using #new, use #unit instead' do
+    expect { Maybe.new(1) }.to raise_error NoMethodError
+  end 
+
+  it 'nil as value always returns Nothing()' do
+     Maybe(nil).a.b.c.should == Nothing
+  end
+
+  it 'on non-existant methods, returns Nothing' do
+    Maybe({}).a.b.c.should == Nothing
+  end
+
+  describe Monadic::Nothing do
+    it_behaves_like 'a Monad' do
+      let(:monad) { Nothing }
+    end
+
+    it 'Nothing stays Nothing' do
+      Maybe(nil).fetch.should == Nothing
+      Maybe(nil)._.should == Nothing
+      Maybe(nil).empty?.should be_true
+    end  
+
+    it 'Nothing#to_s is "Nothing"' do
+      option = Maybe(nil)
+      "#{option}".should   == "Nothing"
+      Nothing.to_s.should == "Nothing"
+    end
+
+    it 'Nothing is always empty' do
+      Nothing.empty?.should be_true
+      Maybe(nil).empty?.should be_true
+    end
+
+    it '[] as value always returns Nothing()' do
+      Maybe([]).a.should == Nothing
+    end
+
+    it 'is always empty and false' do
+      Nothing.empty?.should be_true
+      Nothing.truly?.should be_false
+    end
+  end
+
+  describe Monadic::Just do
+    it_behaves_like 'a Monad' do
+      let(:monad) { Just }
+    end
+
+    it 'Just stays Just' do
+      Maybe('foo').should be_kind_of(Just) 
+      Maybe('foo').empty?.should be_false
+    end
+
+    it 'Just#to_s is "Just(value)"' do
+      Just.unit(123).to_s.should == "Just(123)"
+    end
+  end
+
+  it 'calling methods on Maybe always returns an Maybe with the transformed value' do
+    Maybe('FOO').downcase.should == Just('foo') 
+  end
+
+  it '#fetch returns the value of an option' do 
+    Maybe('foo').fetch.should == 'foo'
+    Maybe('foo')._.should == 'foo'
+  end
+
+  it 'returns the value of an option with a default, in case value is Nothing' do
+    Maybe(nil).fetch('bar').should == 'bar'
+    Maybe(nil)._('bar').should == 'bar'
+  end
+
+  it 'returns the value and not the default if it is Just' do
+    Maybe('FOO').downcase.fetch('bar').should == 'foo'
+    Maybe('FOO').downcase._('bar').should == 'foo'
+  end
+
+  it 'is never falsey' do
+    Maybe('foo').should_not be_false
+    Maybe(nil).should_not be_false
+    Maybe(false).truly?.should be_false
+    Maybe(true).truly?.should be_true
+    Maybe(nil).truly?.should be_false
+  end
+
+  it 'handles (kind-of) falsey values' do
+    FalseyUser = Struct.new(:name, :subscribed)
+    user = Maybe(FalseyUser.new(name = 'foo', subscribed = true))
+    user.subscribed.fetch(false).should be_true
+    user.subscribed.truly?.should be_true
+
+    user = Maybe(nil)
+    user.subscribed.fetch(false).should be_false
+    user.subscribed.truly?.should be_false
+  end
+
+  it 'allows to use map' do
+    Maybe(nil).map { |e| Hash.new(:key => e) }.should == Nothing
+    Maybe('foo').map { |e| Hash.new(:key => e) }.should == Just(Hash.new(:key => 'foo'))
+    Maybe([1,2]).map { |e| e.to_s }.should == Just(["1", "2"])
+  end
+
+  it 'allows to use select' do
+    Maybe('foo').select  { |e| e.start_with?('f') }.should == Just('foo')
+    Maybe('bar').select  { |e| e.start_with?('f') }.should == Nothing
+    Maybe(nil).select    { |e| e.never_called     }.should == Nothing
+    Maybe([1, 2]).select { |e| e == 1             }.should == Just([1])
+  end
+
+  it 'acts as an array' do
+    Maybe('foo').to_a.should == ['foo']
+    Maybe(['foo', 'bar']).to_a.should == ['foo', 'bar']
+    Maybe(nil).to_a.should == []
+  end
+
+  it 'diving into hashes' do
+    Maybe({})['a']['b']['c'].should == Nothing
+    Maybe({a: 1})[:a]._.should == 1
+  end
+
+  it 'should support Rumonades example' do
+    require 'active_support/time'
+    def format_date_in_march(time_or_date_or_nil)
+    Maybe(time_or_date_or_nil).    # wraps possibly-nil value in an Maybe monad (Some or Nothing)
+      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 Nothing)
+      map(&:to_s).                  # transforms a contained Date value into a String value
+      map {|s| s.gsub('-', '')}.    # transforms a contained String value by removing '-'
+      fetch("not in march!")        # returns the contained value, or the alternative if Nothing
+    end
+
+    format_date_in_march(nil).should == "not in march!"
+    format_date_in_march(Time.parse('2009-01-01 01:02')).should == "not in march!"
+    format_date_in_march(Time.parse('2011-03-21 12:34')).should == "20110321"    
+  end
+
+end

data/spec/monad_axioms.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+shared_examples 'a Monad' do
+  describe 'axioms' do
+    it '1st monadic law: left-identity' do
+      f = ->(value) { monad.unit(value + 1) }
+      monad::unit(1).bind do |value|
+        f.(value)
+      end.should == f.(1)
+    end
+
+    it '2nd monadic law: right-identy - unit and bind do not change the value' do
+      monad.unit(1).bind do |value|
+        monad.unit(value)
+      end.should == monad.unit(1)
+    end
+
+    it '3rd monadic law: associativity' do 
+      f = ->(value) { monad.unit(value + 1)   }
+      g = ->(value) { monad.unit(value + 100) }    
+
+      id1 = monad.unit(1).bind do |a|
+        f.(a)
+      end.bind do |b| 
+        g.(b) 
+      end
+
+      id2 = monad.unit(1).bind do |a|
+        f.(a).bind do |b|
+          g.(b)
+        end
+      end
+
+      id1.should == id2
+    end    
+  end
+end

data/spec/monad_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Monadic::Monad do
+  it_behaves_like 'a Monad' do 
+    let(:monad) { Monad }
+  end
+
+  it '#to_s shows the monad name and its value' do
+    Monad.unit(1).to_s.should == 'Monad(1)'
+    Monad.unit(nil).to_s.should == 'Monad(nil)'
+  end
+end

data/spec/spec_helper.rb

@@ -3,3 +3,6 @@ Bundler.require(:default, :test)
 
 $LOAD_PATH << File.expand_path('../../lib', __FILE__)
 require File.expand_path('../../lib/monadic', __FILE__)
+
+require 'monad_axioms'
+require 'jruby_fixes'

data/spec/validation_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Validation' do
+describe Monadic::Validation do
   Person = Struct.new(:age, :gender, :sobriety, :name)
 
   it 'a projection of Success and Failure' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: monadic
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-02 00:00:00.000000000 Z
+date: 2012-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -107,7 +107,23 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: brings some functional goodness to ruby
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: brings some functional goodness to ruby by giving you some monads
 email:
 - pz@anixe.pl
 executables: []
@@ -116,6 +132,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - CHANGELOG.md
 - Gemfile
 - Guardfile
@@ -125,12 +142,16 @@ files:
 - lib/monadic.rb
 - lib/monadic/either.rb
 - lib/monadic/errors.rb
-- lib/monadic/option.rb
+- lib/monadic/maybe.rb
+- lib/monadic/monad.rb
 - lib/monadic/validation.rb
 - lib/monadic/version.rb
 - monadic.gemspec
 - spec/either_spec.rb
-- spec/option_spec.rb
+- spec/jruby_fixes.rb
+- spec/maybe_spec.rb
+- spec/monad_axioms.rb
+- spec/monad_spec.rb
 - spec/spec_helper.rb
 - spec/validation_spec.rb
 homepage: http://github.com/pzol/monadic
@@ -159,6 +180,10 @@ specification_version: 3
 summary: see README
 test_files:
 - spec/either_spec.rb
-- spec/option_spec.rb
+- spec/jruby_fixes.rb
+- spec/maybe_spec.rb
+- spec/monad_axioms.rb
+- spec/monad_spec.rb
 - spec/spec_helper.rb
 - spec/validation_spec.rb
+has_rdoc: 

data/lib/monadic/option.rb

@@ -1,101 +0,0 @@
-require 'singleton'
-# Represents optional values. Instances of Option are either an instance of Some or the object None.
-#
-
-# Helper function which returns Some or None respectively, depending on their value
-# I find this moar simplistic in ruby than the traditional #bind and #unit
-def Option(value)
-  return Monadic::None if value.nil? || (value.respond_to?(:empty?) && value.empty?)
-  return Monadic::Some.new(value)
-end
-alias :Some  :Option
-alias :Maybe :Option
-
-
-# Represents the Option if there is some value available
-module Monadic
-  class Some
-    def initialize(value)
-      @value = value
-    end
-
-    def to_ary
-      return [@value].flatten if @value.respond_to? :flatten
-      return [@value]
-    end
-    alias :to_a :to_ary
-
-    def empty?
-      false
-    end
-
-    def truly?
-      @value == true
-    end
-
-    def fetch(default=None, &block)
-      return block.call(@value)  if block_given?
-      return @value
-    end
-    alias :or :fetch
-    alias :_  :fetch
-
-    def map(func = nil, &block)
-      return Option(@value.map(&block)) if @value.is_a?(Enumerable)
-      return Option((func || block).call(@value))
-    end
-
-    def method_missing(m, *args)
-      Option(@value.__send__(m, *args))
-    end
-
-    def select(func = nil, &block)
-      return Option(@value.select(&block)) if @value.is_a?(Enumerable)
-      return None unless (func || block).call(@value)
-      return self
-    end
-
-    def to_s
-      "Some(#{@value.to_s})"
-    end
-
-    def ==(other)
-      return false unless other.is_a? Some
-      @value == other.instance_variable_get(:@value)
-    end    
-  end
-
-  # Represents the Option if there is no value available
-  class None
-    class << self
-      def to_ary
-        []
-      end
-      alias :to_a :to_ary
-
-      def empty?
-        true
-      end
-
-      def fetch(default=nil)
-        raise NoValueError if default.nil?
-        default
-      end
-      alias :or :fetch
-      alias :_  :fetch
-
-      def method_missing(m, *args)
-        self
-      end
-
-      def to_s
-        'None'
-      end
-
-      def truly?
-        false
-      end
-
-    end
-  end
-end

data/spec/option_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-
-describe 'Option' do 
-  it 'nil as value always returns None()' do
-     Option(nil).a.b.c.should == None
-  end
-
-  it 'None stays None' do
-    expect { Option(nil)._ }.to raise_error Monadic::NoValueError
-    Option(nil).empty?.should be_true
-  end
-
-  it 'Some stays Some' do
-    Option('foo').should be_kind_of(Some) 
-    Option('foo').empty?.should be_false
-  end
-
-  it 'Some#to_s is "Some(value)"' do
-    Some(123).to_s.should == "Some(123)"
-  end
-
-  it 'None#to_s is "None"' do
-    option = Option(nil)
-    "#{option}".should   == "None"
-  end
-
-  it 'None is always empty' do
-    None.empty?.should be_true
-    Maybe(nil).empty?.should be_true
-  end
-
-  it '[] as value always returns None()' do
-    Option([]).a.should == None
-  end
-
-  it 'calling methods on Option always returns an Option with the transformed value' do
-    Option('FOO').downcase.should == Some('foo')
-  end
-
-  it '#fetch returns the value of an option' do 
-    Option('foo').fetch.should == 'foo'
-    Option('foo')._.should == 'foo'
-  end
-
-  it 'returns the value of an option with a default, in case value is None' do
-    Option(nil).fetch('bar').should == 'bar'
-    Option(nil)._('bar').should == 'bar'
-  end
-
-  it 'returns the value and not the default if it is Some' do
-    Option('FOO').downcase.fetch('bar').should == 'foo'
-    Option('FOO').downcase._('bar').should == 'foo'
-  end
-
-  it 'returns the value applied to a block if it is Some' do
-    Option('foo').fetch('bar') { |val| "You are logged in as #{val}" }.should == 'You are logged in as foo'
-    Option(nil).fetch('You are not logged in') { |val| "You are logged in as #{val}" }.should == 'You are not logged in'
-  end
-
-  it 'is never falsey' do
-    Option('foo').should_not be_false
-    Option(nil).should_not be_false
-  end
-
-  class User 
-    attr_reader :name
-    def initialize(name)
-      @name = name
-    end
-    def subscribed?
-      true
-    end
-  end
-
-  it 'allows to use a block with fetch and _' do
-    user = Option(User.new('foo'))
-    user.fetch('You are not logged in') { |user| "You are logged in as #{user.name}" }.should == 'You are logged in as foo'
-  end
-
-  it 'handles (kind-of) falsey values' do
-    user = Option(User.new('foo'))
-    user.subscribed?.or(false).should be_true
-    user.subscribed?.truly?.should be_true
-
-    user = Option(nil)
-    user.subscribed?.or(false).should be_false
-    user.subscribed?.truly?.should be_false
-  end
-
-  it 'allows to use map' do
-    Option(nil).map { |e| Hash.new(:key => e) }.should == None
-    Option('foo').map { |e| Hash.new(:key => e) }.should == Some(Hash.new(:key => 'foo'))
-    Option([1,2]).map { |e| e.to_s }.should == Some(["1", "2"])
-  end
-
-  it 'allows to use select' do
-    Option('foo').select  { |e| e.start_with?('f') }.should == Some('foo')
-    Option('bar').select  { |e| e.start_with?('f') }.should == None
-    Option(nil).select    { |e| e.never_called     }.should == None
-    Option([1, 2]).select { |e| e == 1             }.should == Some([1])
-  end
-
-  it 'acts as an array' do
-    Option('foo').to_a.should == ['foo']
-    Option(['foo', 'bar']).to_a.should == ['foo', 'bar']
-    Option(nil).to_a.should == []
-  end
-
-  it 'diving into hashes' do
-    Maybe({})['a']['b']['c'].should == None
-    Maybe({a: 1})[:a]._.should == 1
-  end
-
-  it 'should support Rumonades example' do
-    require 'active_support/time'
-    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 '-'
-      fetch("not in march!")        # returns the contained value, or the alternative if None
-    end
-
-    format_date_in_march(nil).should == "not in march!"
-    format_date_in_march(Time.parse('2009-01-01 01:02')).should == "not in march!"
-    format_date_in_march(Time.parse('2011-03-21 12:34')).should == "20110321"    
-  end
-end