rumonade 0.2.0 → 0.2.1

data/HISTORY.md

@@ -0,0 +1,29 @@
+# HISTORY
+
+## v0.2.1 (Oct 22, 2011)
+
+  - fixed Option#map to disallow becoming None on a nil result
+  - other fixes and documentation updates
+  - See full list @ https://github.com/ms-ati/rumonade/compare/v0.2.0...v0.2.1
+
+## v0.2.0 (Oct 18, 2011)
+
+  - added a scala-like Either class w/ LeftProjection and RightProjection monads
+
+## v0.1.2 (Oct 12, 2011)
+
+  - progress towards Either class
+  - changed documentation to yard from rdoc
+
+## v0.1.1 (Sep 19, 2011)
+
+  - added a first stab at documentation for Option
+  - fixed certain errors with #map
+  - added #select
+
+## v0.1.0 (Sep 17, 2011)
+
+  - Initial Feature Set
+    - general implementation and testing of monadic laws based on `unit` and `bind`
+    - scala-like Option class w/ Some & None
+    - scala-like extensions to Array

data/README.rdoc

@@ -2,7 +2,7 @@
 
 Project: github[http://github.com/ms-ati/rumonade]
 
-Documentation: rubydoc.info[http://rubydoc.info/gems/rumonade/0.2.0/file/README.rdoc]
+Documentation: rubydoc.info[http://rubydoc.info/gems/rumonade/0.2.1/file/README.rdoc]
 
 == A Ruby[http://www.ruby-lang.org] Monad[http://en.wikipedia.org/wiki/Monad_(functional_programming)] Library, Inspired by Scala[http://www.scala-lang.org]
 

data/lib/rumonade.rb

@@ -27,6 +27,7 @@ require "rumonade/lazy_identity"
 require "rumonade/option"
 require "rumonade/array"
 require "rumonade/either"
+require "rumonade/error_handling"
 
 # = Rumonade
 #

data/lib/rumonade/either.rb

@@ -1,4 +1,3 @@
-require 'singleton'
 require 'rumonade/monad'
 
 module Rumonade

data/lib/rumonade/error_handling.rb

@@ -0,0 +1,67 @@
+require "delegate"
+
+module Rumonade
+
+  # A partial function is a unary function where the domain does not necessarily include all values.
+  # The function {#defined_at?} allows to test dynamically if a value is in the domain of the function.
+  #
+  # NOTE: This is only here to mimic the Scala library just enough to allow a close translation of the exception
+  # handling functionality. It's not because I'm the sort that just loves pure functional idioms so damn much for
+  # their own sake. Just FYI.
+  class PartialFunction < DelegateClass(Proc)
+    def initialize(defined_at_proc, call_proc)
+      super(call_proc)
+      @defined_at_proc = defined_at_proc
+    end
+
+    # Checks if a value is contained in the function's domain.
+    # @param x the value to test
+    # @return [Boolean] Returns +true+, iff +x+ is in the domain of this function, +false+ otherwise.
+    def defined_at?(x)
+      @defined_at_proc.call(x)
+    end
+
+    # Composes this partial function with a fallback partial function which
+    # gets applied where this partial function is not defined.
+    # @param [PartialFunction] other the fallback function
+    # @return [PartialFunction] a partial function which has as domain the union of the domains
+    #         of this partial function and +other+. The resulting partial function takes +x+ to +self.call(x)+
+    #         where +self+ is defined, and to +other.call(x)+ where it is not.
+    def or_else(other)
+      PartialFunction.new(lambda { |x| self.defined_at?(x) || other.defined_at?(x) },
+                          lambda { |x| if self.defined_at?(x) then self.call(x) else other.call(x) end })
+    end
+
+    # Composes this partial function with a transformation function that
+    # gets applied to results of this partial function.
+    # @param  [Proc] func the transformation function
+    # @return [PartialFunction] a partial function with the same domain as this partial function, which maps
+    #         arguments +x+ to +func.call(self.call(x))+.
+    def and_then(func)
+      PartialFunction.new(@defined_at_proc, lambda { |x| func.call(self.call(x)) })
+    end
+  end
+
+  # Classes representing the components of exception handling.
+  # Each class is independently composable.  Some example usages:
+  #
+  #   require "rumonade"
+  #   require "uri"
+  #
+  #   s = "http://"
+  #   x1 = catching(URI::InvalidURIError).opt { URI.parse(s) }
+  #   x2 = catching(URI::InvalidURIError, NoMethodError).either { URI.parse(s) }
+  #
+  module ErrorHandling
+
+    # Should re-raise exceptions like +Interrupt+ and +NoMemoryError+ by default.
+    # @param [Exception] ex the exception to consider re-raising
+    # @return [Boolean] Returns +true+ if a subclass of +StandardError+, otherwise +false+.
+    def should_reraise?(ex)
+      case ex
+        when StandardError; false
+        else true
+      end
+    end
+  end
+end

data/lib/rumonade/option.rb

@@ -40,7 +40,7 @@ module Rumonade # :nodoc:
     class << self
       # @return [Option] Returns an +Option+ containing the given value
       def unit(value)
-        Rumonade.Option(value)
+        Rumonade.Some(value)
       end
 
       # @return [Option] Returns the empty +Option+
@@ -101,7 +101,7 @@ module Rumonade # :nodoc:
     end
 
     def to_s
-      "Some(#{value.to_s})"
+      "Some(#{value.nil? ? 'nil' : value.to_s})"
     end
   end
 

data/lib/rumonade/version.rb

@@ -1,3 +1,3 @@
 module Rumonade
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/test/error_handling_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class ErrorHandlingTest < Test::Unit::TestCase
+  include Rumonade
+  include Rumonade::ErrorHandling
+
+  def test_partial_function_constructor_delegates_call_and_defined_at_to_given_procs
+    pf = PartialFunction.new(lambda { |x| x < 1000 }, lambda { |x| x * 10 })
+    assert pf.defined_at?(999)
+    assert !pf.defined_at?(1000)
+    assert_equal 420, pf.call(42)
+  end
+
+  def test_partial_function_or_else_returns_a_partial_function_with_union_of_defined_at_predicates
+    pf = PartialFunction.new(lambda { |x| x < 1000 }, lambda { |x| x * 10 })
+      .or_else(PartialFunction.new(lambda { |x| x > 5000 }, lambda { |x| x / 5 }))
+    assert pf.defined_at?(999)
+    assert !pf.defined_at?(1000)
+    assert !pf.defined_at?(5000)
+    assert pf.defined_at?(5001)
+  end
+
+  def test_partial_function_or_else_returns_a_partial_function_with_fallback_when_outside_defined_at
+    pf = PartialFunction.new(lambda { |x| x < 1000 }, lambda { |x| x * 10 })
+      .or_else(PartialFunction.new(lambda { |x| x > 5000 }, lambda { |x| x / 5 }))
+    assert_equal 9990, pf.call(999)
+    assert_equal 1001, pf.call(5005)
+  end
+
+  def test_partial_function_and_then_returns_a_partial_function_with_func_called_on_result_of_pf_call
+    pf = PartialFunction.new(lambda { |x| x < 1000 }, lambda { |x| x * 10 })
+      .and_then(lambda { |x| x / 5 })
+    assert_equal 1800, pf.call(900)
+  end
+
+  def test_should_reraise_returns_true_if_not_subclass_of_standard_error
+    assert should_reraise?(NoMemoryError.new)
+    assert !should_reraise?(ZeroDivisionError.new)
+  end
+end

data/test/option_test.rb

@@ -4,10 +4,10 @@ class OptionTest < Test::Unit::TestCase
   include Rumonade
   include MonadAxiomTestHelpers
 
-  def test_when_option_with_nil_returns_none_singleton
-    assert_same None, Option.unit(nil)
+  def test_when_option_with_nil_returns_none_singleton_except_unit
     assert_same None, Option(nil)
     assert_same NoneClass.instance, None
+    assert_not_equal None, Option.unit(nil)
   end
 
   def test_when_option_with_value_returns_some
@@ -15,6 +15,7 @@ class OptionTest < Test::Unit::TestCase
     assert_equal Some(42), Option(42)
     assert_equal Some(42), Some.new(42)
     assert_not_equal None, Some(nil)
+    assert_equal Some(nil), Option.unit(nil)
   end
 
   def test_when_option_constructor_raises
@@ -85,6 +86,7 @@ class OptionTest < Test::Unit::TestCase
     assert_equal "Some(1)", Some(1).to_s
     assert_equal "None", None.to_s
     assert_equal "Some(Some(None))", Some(Some(None)).to_s
+    assert_equal "Some(nil)", Some(nil).to_s
   end
 
   def test_each_behaves_correctly
@@ -108,4 +110,10 @@ class OptionTest < Test::Unit::TestCase
     assert_equal None, Some(1).select { |n| n < 0 }
     assert_equal None, None.select { |n| n < 0 }
   end
+
+  def test_some_map_to_nil_follows_scala_behavior_returning_some_of_nil
+    # scala> Option(1).map { x => null }
+    # res0: Option[Null] = Some(null)
+    assert_equal Some(nil), Option(1).map { |n| nil }
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: rumonade
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Marc Siegel
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-18 00:00:00 Z
+date: 2011-10-22 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: test-unit
@@ -34,14 +34,15 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
-- CHANGELOG.rdoc
 - Gemfile
+- HISTORY.md
 - MIT-LICENSE.txt
 - README.rdoc
 - Rakefile
 - lib/rumonade.rb
 - lib/rumonade/array.rb
 - lib/rumonade/either.rb
+- lib/rumonade/error_handling.rb
 - lib/rumonade/errors.rb
 - lib/rumonade/lazy_identity.rb
 - lib/rumonade/monad.rb
@@ -50,6 +51,7 @@ files:
 - rumonade.gemspec
 - test/array_test.rb
 - test/either_test.rb
+- test/error_handling_test.rb
 - test/lazy_identity_test.rb
 - test/option_test.rb
 - test/test_helper.rb
@@ -83,6 +85,7 @@ summary: A Scala-inspired Monad library for Ruby
 test_files: 
 - test/array_test.rb
 - test/either_test.rb
+- test/error_handling_test.rb
 - test/lazy_identity_test.rb
 - test/option_test.rb
 - test/test_helper.rb

data/CHANGELOG.rdoc

@@ -1,22 +0,0 @@
-=== 0.2.0 / 2011-10-18
-
-* scala-like Either class w/ LeftProjection and RightProjection monads
-
-=== 0.1.2 / 2011-10-12
-
-* Progress towards Either
-  * changed documentation to yard from rdoc
-
-=== 0.1.1 / 2011-09-19
-
-* Maintenance
-  * added a first stab at documentation for Option
-  * fixed certain errors with #map
-  * added #select
-
-=== 0.1.0 / 2011-09-17
-
-* Initial Feature Set
-  * general implementation and testing of monadic laws based on `unit` and `bind`
-  * scala-like Option class w/ Some & None
-  * scala-like extensions to Array