monadic 0.5.0 → 0.6.0

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## v0.6 (unreleased)
+
+Extend `Try` to also support lambdas.
+
+The first parameter of `Try` can be used as a predicate and the block as formatter
+
+    Try(true)                              == Success(true)
+    Try(false) { "string" }                == Failure("string")
+    Try(false) { "success" }.else("fail")  == Failure("fail")
+
+`Maybe` supports `#proxy` to avoid naming clashes between the underlying value and `Maybe` itself.
+
+    Maybe({a: 1}).proxy.fetch(:a)          == Maybe(1)
+    # this is in effect syntactic sugar for
+    Maybe({a: 1}).map {|e| e.fetch(:a) }
+
+`Nothing#or` coerces the or value into a Maybe, thus
+
+    Maybe(nil).or(1)          == Just(1)
+    Maybe(nil).or(nil)        == Nothing
+
+`Either` coerces now `Just` and `Nothing` into `Success` and `Failure`
+
+    Either(Just.new(1))       == Success(1)
+    Either(Nothing)           == Failure(Nothing)
+
 ## v0.5.0
 
 Add the `Try` helper which works similar to Either, but takes a block
@@ -38,7 +64,7 @@ Instead the new `Monad#flat_map` function operates on the underlying value as on
 ## v0.1.1
 
 `Either()` coerces only `StandardError` to `Failure`, other exceptions higher in the hierarchy are will break the flow.  
-Thanks to @pithyless for the suggestion. 
+Thanks to @pithyless for the suggestion.
 
 Monad is now a Module instead of a Class as previously. This fits the Monad metaphor better. Each monad must now implement the unit method itself, which is the correct way to do anyway.
 
@@ -60,7 +86,7 @@ See [examples/validation.rb](https://github.com/pzol/monadic/blob/master/example
 and [examples/validation_module](https://github.com/pzol/monadic/blob/master/examples/validation_module.rb)
 
 
-## v0.0.7 
+## v0.0.7
 
 Implements the #map method for all Monads. It works on value types and on Enumerable collections.  
 Provide a proc or a block and it will return a transformed value or collection boxed back in the monad.
@@ -88,7 +114,7 @@ Removed `Maybe#fetch` call with block`
 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 
+## v0.0.5
 
 Removed the `#chain` method alias for bind in `Either`.
 

data/README.md

@@ -3,7 +3,7 @@
 
 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").  
+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):
 
@@ -21,11 +21,11 @@ A monad is most effectively described as a computation that eventually returns a
 ### Maybe
 Most people probably will be interested in the Maybe monad, as it solves the problem with nil invocations, similar to [andand](https://github.com/raganwald/andand) and others.
 
-Maybe is an optional type, which helps to handle error conditions gracefully. The one thing to remember about option is: 'What goes into the Maybe, stays in the Maybe'. 
+Maybe is an optional type, which helps to handle error conditions gracefully. The one thing to remember about option is: 'What goes into the Maybe, stays in the Maybe'.
 
 
 ```ruby
-Maybe(User.find(123)).name._         # ._ is a shortcut for .fetch 
+Maybe(User.find(123)).name._         # ._ is a shortcut for .fetch
 
 # if you prefer the alias Maybe instead of option
 Maybe(User.find(123)).name._
@@ -52,7 +52,7 @@ 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').downcase._     == "foo"
 Maybe('foo').empty?         == false          # always non-empty
 Maybe('foo').truly?         == true           # depends on the boxed value
 Maybe(false).empty?         == false
@@ -60,8 +60,8 @@ Maybe(false).truly?         == false
 ```
 
 Map, select:
-    
-```ruby    
+
+```ruby
 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
@@ -90,9 +90,10 @@ Maybe(1).to_s             == '1'
 ```
 
 `#or`
-Maybe(nil).or(1)          == 1
-Maybe(1).or(2)            == 1
-Maybe(nil).or(nil)        == Just(nil)
+Maybe(nil).or(1)          == Just(1)
+Maybe(1).or(2)            == Just(1)
+Maybe(nil).or(1)          == Just(1)
+Maybe(nil).or(nil)        == Nothing
 
 Falsey values (kind-of) examples:
 
@@ -110,6 +111,14 @@ Remember! a Maybe is never false (in Ruby terms), if you want to know if it is f
 
 `#truly?` will return true or false, always.
 
+`Maybe` supports `#proxy` to avoid naming clashes between the underlying value and `Maybe` itself.
+
+```ruby
+Maybe({a: 1}).proxy.fetch(:a)          == Maybe(1)
+# this is in effect syntactic sugar for
+Maybe({a: 1}).map {|e| e.fetch(:a) }
+```
+
 Slug example
 
 ```ruby
@@ -158,11 +167,11 @@ The `Either()` wrapper works like a coercon. It will treat all falsey values `ni
 ```ruby
 result = parse_and_validate_params(params).                 # must return a Success or Failure inside
             bind ->(user_id) { User.find(user_id) }.        # if #find returns null it will become a Failure
-            bind ->(user)    { authorized?(user); user }.   # if authorized? raises an Exception, it will be a Failure 
+            bind ->(user)    { authorized?(user); user }.   # if authorized? raises an Exception, it will be a Failure
             bind ->(user)    { UserDecorator(user) }
 
 if result.success?
-  @user = result.fetch                                      # result.fetch or result._ contains the 
+  @user = result.fetch                                      # result.fetch or result._ contains the inner value
   render 'page'
 else
   @error = result.fetch
@@ -205,7 +214,7 @@ Another example:
 ```ruby
 Success(params).
   bind ->(params)   { Either(params.fetch(:path)) }        # fails if params does not contain :path
-  bind ->(path)     { load_stuff(params)          }        # 
+  bind ->(path)     { load_stuff(params)          }        #
 ```
 
 `Either#else` allows to provide alternate values in case of `Failure`:
@@ -231,18 +240,29 @@ result = Either.chain do
 end
 
 result == Success(101)
-```  
+```
 
 #### Try
 
-`Try` helper which works similar to Either, but takes a block
+`Try` helper which works similar to Either, but takes a block. Think of it as a secure if-then-else.
 
 ```ruby
 Try { Date.parse('2012-02-30') }                                        == Failure
 Try { Date.parse('2012-02-28') }                                        == Success
-Try { Date.parse('2012-02-30') }.else {|e| "Exception: #{e.message}" }  == Failure("Exception: invalid date")
-```
 
+date_s = '2012-02-30'
+Try { Date.parse(date_s) }.else {|e| "#{e.message} #{date_s}" }        == Failure("invalid date 2012-02-30")
+
+# with a predicate
+Try(true)                                                               == Success(true)
+Try(false) { "string" }                                                 == Failure("string")
+Try(false) { "success"}.else("fail")                                    == Failure("fail")
+
+VALID_TITLES = %w[MR MRS]
+title = 'MS'
+Try(VALID_TITLES.inlude?(title)) { title }.else { "title must be on of '#{VALID_TITLES.join(', ')}'' but was '#{title}'"}
+                                                                        == "title must be on of 'MR, MR' but was 'MS'"
+```
 
 ### Validation
 The Validation applicative functor, takes a list of checks within a block. Each check must return either Success of Failure.  
@@ -267,13 +287,13 @@ def validate(person)
     when :sober, :tipsy; Success(sobriety)
     when :drunk        ; Failure('No drunks allowed')
     else Failure("Sobriety state '#{sobriety}' is not allowed")
-    end 
+    end
   }
 
   check_gender = ->(gender) {
     gender == :male || gender == :female ? Success(gender) : Failure("Invalid gender #{gender}")
   }
-    
+
   Validation() do
     check { check_age.(person.age);          }
     check { check_sobriety.(person.sobriety) }
@@ -306,8 +326,8 @@ Identity.unit([1,2]).map {|v| v + 1}                             == Identity([2,
 
 __#bind__ allows (priviledged) access to the boxed value. This is the traditional _no-magic_ `#bind` as found in Haskell, 
 You` are responsible for re-wrapping the value into a Monad again.
-  
-```ruby  
+
+```ruby
 # due to the way it works, it will simply return the value, don't rely on this though, different Monads may
 # implement bind differently (e.g. Maybe involves some _magic_)
 Identity.unit('foo').bind(&:capitalize)                          == Foo
@@ -356,8 +376,8 @@ 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.
-
+Monadic is tested under ruby MRI 1.9.2, 1.9.3
+jruby 1.9 mode, rbx 1.9 mode are currently not passing the tests on travis
 
 ## Contributing
 

data/lib/monadic/either.rb

@@ -8,7 +8,9 @@ module Monadic
 
     def self.unit(value)
       return value if value.is_a? Either
-      return Failure.new(value) if value.nil? || (value.respond_to?(:empty?) && value.empty?) || !value
+      return Nothing                  if value.is_a? Nothing
+      return Success.new(value.fetch) if value.is_a? Just
+      return Failure.new(value)       if value.nil? || (value.respond_to?(:empty?) && value.empty?) || !value
       return Success.new(value)
     end
 

data/lib/monadic/maybe.rb

@@ -1,13 +1,13 @@
 module Monadic
-  class Maybe 
+  class Maybe
     include Monadic::Monad
-    
+
     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 
+    # Initialize is private, because it always would return an instance of Maybe, but Just or Nothing
     # are required (Maybe is abstract).
     private_class_method :new
 
@@ -44,6 +44,20 @@ module Monadic
       Maybe(@value.__send__(m, *args))
     end
 
+    class Proxy < BasicObject
+      def initialize(maybe)
+        @maybe = maybe
+      end
+
+      def method_missing(m, *args)
+        @maybe.map { |e| e.__send__(m, *args)  }
+      end
+    end
+
+    def proxy
+      @proxy ||= Proxy.new(self)
+    end
+
     # @return always self for Just
     def or(other)
       self
@@ -66,13 +80,12 @@ module Monadic
         self
       end
 
-      # @return an alternative value, the passed value is NOT coerced into Maybe, thus Nothing.or(nil) will be Just(nil)
+      # @return an alternative value, the passed value is coerced into Maybe, thus Nothing.or(1) will be Just(1)
       def or(other)
-        Just.new(other)
+        Maybe.unit(other)
       end
 
       # def respond_to?
-
       # end
 
       def to_ary
@@ -87,6 +100,10 @@ module Monadic
       def truly?
         false
       end
+
+      def empty?
+        true
+      end
     end
   end
 

data/lib/monadic/try.rb

@@ -1,8 +1,12 @@
 module Monadic
-  def Try(proc = nil, &block)
+  ## Wrap a block or a predicate to always return Success or Failure.
+  ## It will catch StandardError and return as a Failure.
+  def Try(arg = nil, &block)
     begin
-      return Either(proc) unless proc.nil? || proc.is_a?(Proc)
-      return Either((proc || block).call)
+      predicate = arg.is_a?(Proc) ? arg.call : arg
+      return Either(block.call) if block_given? && predicate.nil?
+      return Either(predicate).class.unit(block.call) if block_given?   # use predicate for Success/Failure and block for value
+      return Either(predicate)
     rescue => error
       Failure(error)
     end

data/lib/monadic/version.rb

@@ -1,3 +1,3 @@
 module Monadic
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/spec/either_spec.rb

@@ -39,6 +39,10 @@ describe Monadic::Either do
     Failure(1).should_not == Failure(2)
   end
 
+  it 'Either(Nothing) is a Failure' do
+    Either(Nothing).should == Failure(Nothing)
+  end
+
   it 'wraps a nil result to Failure' do
     Success(nil).bind { nil }.should == Failure(nil)
   end
@@ -241,6 +245,14 @@ describe Monadic::Either do
     either.fetch.should be_a KeyError
   end
 
+  it 'Either(Nothing) returns a Failure' do
+    Either(Nothing).should == Failure(Nothing)
+  end
+
+  it 'Either(Just) returns a Success' do
+    Either(Just.new(1)).should == Success(1)
+  end
+
   it 'instance variables' do
     result = Either.chain do
       bind { @map = { one: 1, two: 2 } }

data/spec/examples/builder_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+class BSONTestConverter
+  class InvalidBSONString < StandardError; end
+  def self.from_string(s)
+    raise InvalidBSONString unless s =~ /^[0-9a-z]{24}$/
+    return self.new(s)
+  end
+
+  def initialize(s)
+    @bson = s
+  end
+
+  def to_s
+    @bson
+  end
+
+  def ==(other)
+    return 0 unless other.is_a? BSONTestConverter
+    return to_s <=> other.to_s
+  end
+end
+
+class DatabaseReader
+  def self.find(id)
+    return { 'request_id' => '197412101130' } if id.to_s == '4fe48bcfcf79520644088180'
+  end
+end
+
+module Transaction
+  def self.fetch(params)
+    return Failure('params must be a Hash') unless params.is_a? Hash
+
+    Either(Maybe(params)['id']).else('id is missing').
+      >= {|v| Try { BSONTestConverter.from_string(v) }.else("id '#{v}' is not a valid BSON id") }.
+      >= {|v| Try { DatabaseReader.find(v)           }.else("'#{v}' not found")                 }
+  end
+
+  def self.logs(request_id)
+    Success([request_id])
+  end
+end
+
+describe 'builder' do
+  # id = BSON::ObjectId.from_string(params[:id])
+    # @tr = MongoMapper.database.collection("log").find_one(id)
+    # @rid = @tr['request_id']
+    # @logs = LogReader.new.links(@rid)
+  it 'builds' do
+    Transaction.fetch({}).should == Failure('id is missing')
+    Transaction.fetch({'id' => '123'                     }).should == Failure("id '123' is not a valid BSON id")
+    Transaction.fetch({'id' => '000000000000000000000000'}).should == Failure("'000000000000000000000000' not found")
+
+    doc = Transaction.fetch({'id' => '4fe48bcfcf79520644088180'})
+    doc.should == Success({"request_id"=>"197412101130"})
+
+    doc.bind { Failure('logs not found') }.should == Failure('logs not found')
+
+    logs = doc.
+      >= {|v| Transaction.logs(v['request_id']) }
+
+    logs.should == Success(['197412101130'])
+  end
+end

data/spec/examples/hotel_booking_spec.rb

@@ -1,16 +1,15 @@
 require 'spec_helper'
 require 'active_support/time'
 
-describe 'Hotel Booking Example' do
-
-  class Request < Struct
+module Monadic
+  class Struct < ::Struct
     def self.create(params, params_module)
-      value = self.create_value(params || {}, params_module)
+      properties = self.create_properties(params || {}, params_module)
 
-      if value.values.all?(&:success?)
-        Success(value)
+      if properties.values.all?(&:success?)
+        Success(properties)
       else
-        Failure(value)
+        Failure(properties)
       end
     end
 
@@ -19,12 +18,11 @@ describe 'Hotel Booking Example' do
     end
 
     def unwrap
-      Struct.new(*members).new(*values.map(&:fetch))
-      # self.class.new(*values.map(&:fetch))
+      ::Struct.new(*members).new(*values.map(&:fetch))
     end
 
     private
-    def self.create_value(params, params_module)
+    def self.create_properties(params, params_module)
       properties = params_module.methods - Module.methods
       request_klas = self.new(*properties)
       properties.reduce(request_klas.new) do |request, property|
@@ -33,57 +31,42 @@ describe 'Hotel Booking Example' do
       end
     end
   end
+end
 
+describe 'Hotel Booking Example' do
   module HotelBookingRequestParams
     extend self
 
     def hotel_code(params)
-      value = params['hotel_code']
-      case
-      when value.nil?
-        Failure('hotel_code must not be empty')
-      when not(value =~ /^[A-Z]{3}[A-Z0-9]{4}$/)
-        Failure('hotel_code must be of pattern XXX0001')
-      else
-        Success(value)
-      end
+      param = params['hotel_code']
+      Try(param =~ /^[A-Z]{3}[A-Z0-9]{4}$/) { param }.else "hotel_code must be of pattern XXX0001, got '#{param}'"
     end
 
     def nights(params)
       value = params.fetch('nights', 0).to_i
-      if value <= 0
-        Failure("nights must be a number greater than 0 (got '#{params['nights']}')")
-      else
-        Success(value)
-      end
+      Try(value > 0) { value }.else "nights must be a number greater than 0, got '#{params['nights']}'"
     end
 
-    VALID_ROOM_TYPE = %w[SR DR TR QR]
+    ROOM_OCCUPANCIES = {'SR' => 1, 'DR' => 2, 'TR' => 3, 'QR' => 4 }
+    VALID_ROOM_TYPES = ROOM_OCCUPANCIES.keys
     def room_type(params)
-      case value = params['room_type']
-      when nil
-        Failure('room_type must not be empty')
-      when is_valid_room_type
-        Success(value)
-      else
-        Failure("room_type '#{value}' must be one of #{VALID_ROOM_TYPE.join(', ')}")
-      end
+      param = params['room_type']
+      Try(VALID_ROOM_TYPES.include?(param)) { param }.else "room_type must be one of '#{VALID_ROOM_TYPES.join(', ')}', got '#{param}'"
     end
 
     def check_in(params)
       param = params['check_in']
-      return Failure("check_in must not be empty")    if param.nil?
-      return Try { Date.parse(param) }.else {|e| "check_in #{e.message} '#{param}'" }
+      Try { Date.parse(param) }.else {|e| "check_in #{e.message}, got '#{param}'" }
     end
 
-    private
-    def is_valid_room_type
-      Object.new.tap {|matcher|
-        def matcher.===(value)
-          VALID_ROOM_TYPE.include? value
-        end
-      }
+    OCCUPANCIES = [1, 2, 3, 4]
+    def guests(params)
+      guests    = params.select {|p| p =~ /^guest/ }.values.compact
+      rt        = params['room_type']
+      occupancy = ROOM_OCCUPANCIES.fetch(rt, 99)
+      Try(guests.count == occupancy) { guests }.else "guests number must match the room_type '#{rt}':#{occupancy}, got #{guests.count}: '#{guests.join(', ')}'"
     end
+
   end
 
   let(:params_proto) do
@@ -96,38 +79,48 @@ describe 'Hotel Booking Example' do
   end
 
   it 'builds a valid request' do
-    result = Request.create(params_proto, HotelBookingRequestParams)
+    result = prepare params_proto
     result.should be_a Success
-    request = result.fetch.unwrap
-    request.hotel_code.should eq "STO0001"
-    request.nights.should eq 3
+    request = result.fetch.unwrap   # the valid object, ready to use
+    request.hotel_code.should == "STO0001"
+    request.check_in.should   == Date.new(2012, 06, 15)
+    request.nights.should     == 3
+    request.room_type.should  == 'DR'
+    request.guests.should     == ['Max Payne', 'Jenny Payne']
+  end
+
+  def prepare(params)
+    Monadic::Struct.create(params, HotelBookingRequestParams)
+  end
+
+  it 'reports too few guests' do
+    result = prepare params_proto.reject {|key| key == 'guest2'}
+    result.should be_a Failure
+    result.fetch.guests.should == Failure("guests number must match the room_type 'DR':2, got 1: 'Max Payne'")
   end
 
   it 'reports an invalid room_type' do
-    params = params_proto.merge 'room_type' => 'XX'
-    result = Request.create(params, HotelBookingRequestParams)
+    result = prepare params_proto.merge 'room_type' => 'XX'
     result.should be_a Failure
-    request = result.fetch
-    request.room_type.should be_a Failure
+    result.fetch.room_type.should be_a Failure
   end
 
   it 'reports an invalid check_in time' do
-    params = params_proto.merge 'check_in' => '2012-11-31'
-    result = Request.create(params, HotelBookingRequestParams)
+    result = prepare params_proto.merge 'check_in' => '2012-11-31'
     result.should be_a Failure
     request = result.fetch
-    request.check_in.should be_a Failure
-    request.check_in.should == Failure("check_in invalid date '2012-11-31'")
+    request.check_in.should == Failure("check_in invalid date, got '2012-11-31'")
   end
 
   it 'builds a failure request with no params' do
-    result = Request.create(nil, HotelBookingRequestParams)
+    result = prepare(nil)
     result.should be_a Failure
     request = result.fetch
-    request.hotel_code.should be_a Failure
-    request.nights.should be_a Failure
-    request.room_type.should be_a Failure
-    request.check_in.should be_a Failure
+    request.hotel_code.should == Failure("hotel_code must be of pattern XXX0001, got ''")
+    request.nights.should     == Failure("nights must be a number greater than 0, got ''")
+    request.room_type.should  == Failure("room_type must be one of 'SR, DR, TR, QR', got ''")
+    request.check_in.should   == Failure("check_in can't convert nil into String, got ''")
+    request.guests.should     == Failure("guests number must match the room_type '':99, got 0: ''")
   end
 
 end

data/spec/maybe_spec.rb

@@ -7,12 +7,17 @@ describe Monadic::Maybe do
 
   it 'Maybe cannot be created using #new, use #unit instead' do
     expect { Maybe.new(1) }.to raise_error NoMethodError
-  end 
+  end
 
   it 'nil as value always returns Nothing()' do
      Maybe(nil).a.b.c.should == Nothing
   end
 
+  it 'Maybe(Just) should return Just' do
+    Maybe(Just(nil)).should == Just(nil)
+    Maybe(Nothing).should == Nothing
+  end
+
   it 'on non-existant methods, returns Nothing' do
     Maybe({}).a.b.c.should == Nothing
   end
@@ -26,7 +31,7 @@ describe Monadic::Maybe do
       Maybe(nil).fetch.should == Nothing
       Maybe(nil)._.should == Nothing
       Maybe(nil).empty?.should be_true
-    end  
+    end
 
     it 'Nothing#to_s is "Nothing"' do
       option = Maybe(nil)
@@ -55,6 +60,10 @@ describe Monadic::Maybe do
 
     it 'Nothing#or returns the alternative' do
       Maybe(nil).or(1).should == Just(1)
+      Nothing.or(1).should == Just(1)
+      Nothing.or(Just(nil)).should == Just(nil)
+      Nothing.something.or(1).should == Just(1)
+      Nothing.something.or(Just(nil)).should == Just(nil)
     end
   end
 
@@ -64,18 +73,19 @@ describe Monadic::Maybe do
     end
 
     it 'Just stays Just' do
-      Maybe('foo').should be_kind_of(Just) 
+      Maybe('foo').should be_kind_of(Just)
       Maybe('foo').empty?.should be_false
     end
 
     it 'Just#to_s is "value"' do
       Just.unit(123).to_s.should == "Just(123)"
+      Just("4fe48bcfcf79520644088180").to_s.should == 'Just("4fe48bcfcf79520644088180")'
     end
 
     it 'Just#or return self' do
       Maybe(1).or(2).should              == Just(1)
-      Maybe(nil).or(nil).should          == Just.new(nil)
-      Maybe(nil).something.or('').fetch.should == ''
+      Maybe(nil).or(nil).should          == Nothing
+      Maybe(nil).something.or(Just('')).fetch.should == Just('')
     end
 
     it 'Just#inspect returns Just(value)' do
@@ -163,7 +173,12 @@ describe Monadic::Maybe do
 
     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"    
+    format_date_in_march(Time.parse('2011-03-21 12:34')).should == "20110321"
   end
 
+  it 'delegates method calls with #proxy' do
+    Maybe({a: 1}).proxy.fetch(:a).should == Maybe(1)
+    Maybe("FOO").proxy.downcase.capitalize.should == Maybe("Foo")
+    Maybe(nil).proxy.downcase.capitalize.bar.should == Nothing
+  end
 end

data/spec/try_spec.rb

@@ -14,14 +14,25 @@ describe 'Monadic::Try' do
     Try { [] }.should be_a Failure
   end
 
-  it 'without a block it works like Either' do
+  it 'with a param, without a block it returns the predicate' do
     Try(true).should be_a Success
     Try(false).should be_a Failure
     Try(nil).should be_a Failure
   end
 
-  it 'with a proc' do
-    pending
+  it 'with a param and with a block it returns the block result' do
+    Try(true)  { 1 }.should == Success(1)
+    Try(false) { 2 }.should == Failure(2)
+    Try(false) { 1 }.else { 2 }.should == Failure(2)
+  end
+
+  it 'with a proc and no block it evaluates the proc' do
+    Try(-> { 1 }).should == Success(1)
+    Try(-> { 1 }) { 2 }.should == Success(2)
+  end
+
+  it 'no params is the same as passing nil as the predicatea' do
+    Try().should == Failure(nil)
   end
 
   it 'returns Success for non-nil values' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: monadic
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-17 00:00:00.000000000 Z
+date: 2012-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -154,6 +154,7 @@ files:
 - spec/core_ext/object_spec.rb
 - spec/either_spec.rb
 - spec/examples/applicative_spec.rb
+- spec/examples/builder_spec.rb
 - spec/examples/hotel_booking_spec.rb
 - spec/jruby_fixes.rb
 - spec/maybe_spec.rb
@@ -176,7 +177,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 44748107420070269
+      hash: 2246458514498594220
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -185,7 +186,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 44748107420070269
+      hash: 2246458514498594220
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -196,6 +197,7 @@ test_files:
 - spec/core_ext/object_spec.rb
 - spec/either_spec.rb
 - spec/examples/applicative_spec.rb
+- spec/examples/builder_spec.rb
 - spec/examples/hotel_booking_spec.rb
 - spec/jruby_fixes.rb
 - spec/maybe_spec.rb