deterministic 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b0f292bd43ef9a647f89e10a27d7ee6c03f9c86
-  data.tar.gz: 353997a1fa950788805f34a170b6fb83f4e84829
+  metadata.gz: 2a2ce59cd264bdbafaa4a86660553c4e407b6607
+  data.tar.gz: d3418defe22825466d5c4bdb7c7363f53c767442
 SHA512:
-  metadata.gz: 943ebb00ce456140da6bf042681b53383fa19fa84ca529f7852d0f0671d089d203b64152a42dd897ec7a1f2a2fca9a646e4aff0bb945bf1fe07ee5963835d73a
-  data.tar.gz: 2f9e20201ac9c8d9fd19672eb7abe5f27a12d156dce4b7b49d6244a1a4363fef7e0344564f0b876a330bf4cd7064c9d40b9d79de940f310a156e30357bbea021
+  metadata.gz: 6226df9e5bef50b905208606a0634aa94b8ca70d61be98318a02ffe6da40bb90ddec4304b6ccfa0a844d5230ab9743d25fa9997c65e5fc64e378e9505e45f08f
+  data.tar.gz: 6b3d7eeb06e263853cdad760a5df74043981f914be4e69ed80b10c37618ce1d6e9134e01a65675ce305d2fc6fa15b7c380dbf3cc760902769f6c9ba1e8e8e227

data/README.md

@@ -22,8 +22,9 @@ Failure(1) << Failure(2)    # => Failure(1)
 Failure(Failure(1))         # => Failure(1)
 Failure(1).map { |v| v + 1} # => Failure(2)
 Failure({a:1}).to_json      # => '{"Failure": {"a":1}}'
+```
 
-### Either#attempt_all
+### Either.attempt_all
 The basic idea is to execute a chain of units of work and make sure all return either `Success` or `Failure`.
 
 ```ruby
@@ -149,6 +150,30 @@ Success(1).match do
 end # => "catch-all"
 ```
 
+## Flow control
+
+Chaininig successfull actions
+
+```ruby
+Success(1).and Success(2)            # => Success(2)
+Success(1).and_then { Success(2) }   # => Success(2)
+
+Success(1).or Success(2)             # => Success(1)
+Success(1).or_else { Success(2) }    # => Success(1)
+```
+
+Chaininig failed actions
+
+```ruby
+Failure(1).and Success(2)            # => Failure(1)
+Failure(1).and_then { Success(2) }   # => Failure(1)
+
+Failure(1).or Success(1)             # => Success(1)
+Failure(1).or_else { |v| Success(v)} # => Success(1)
+```
+
+The value or block result must always be a `Success` or `Failure`
+
 ## core_ext
 You can use a core extension, to include Either in your own class or in Object, i.e. in all classes.
 
@@ -222,7 +247,7 @@ Maybe({}).some?       # => true
 
 ## Mimic
 
-If you want a custom NullObject which mimicks another class
+If you want a custom NullObject which mimicks another class.
 
 ```ruby
 class Mimick

data/lib/deterministic.rb

@@ -10,3 +10,4 @@ require 'deterministic/either'
 require 'deterministic/either/attempt_all'
 require 'deterministic/either/success'
 require 'deterministic/either/failure'
+require 'deterministic/none'

data/lib/deterministic/either.rb

@@ -1,8 +1,15 @@
 module Deterministic
+  # Abstract parent of Success and Failure
   class Either
     include Monad
     include Deterministic::PatternMatching
 
+    def bind(proc=nil, &block)
+      (proc || block).call(value, self.class).tap do |result|
+        raise NotMonadError, "Expected #{result.inspect} to be an Either" unless result.is_a? self.class.superclass
+      end
+    end
+
     def success?
       is_a? Success
     end
@@ -16,6 +23,7 @@ module Deterministic
       return other if other.is_a? Either
     end
 
+    # This is an abstract class, can't ever instantiate it directly
     class << self
       protected :new
     end

data/lib/deterministic/either/failure.rb

@@ -1,5 +1,22 @@
 module Deterministic
   class Failure < Either
     class << self; public :new; end
+
+    def and(other)
+      self
+    end
+
+    def and_then(&block)
+      self
+    end
+
+    def or(other)
+      raise NotMonadError, "Expected #{other.inspect} to be an Either" unless other.is_a? Either
+      other
+    end
+
+    def or_else(&block)
+      bind(&block)
+    end
   end
 end

data/lib/deterministic/either/success.rb

@@ -1,5 +1,22 @@
 module Deterministic
   class Success < Either
     class << self; public :new; end
+
+    def and(other)
+      raise NotMonadError, "Expected #{other.inspect} to be an Either" unless other.is_a? Either
+      other
+    end
+
+    def and_then(&block)
+      bind(&block)
+    end
+
+    def or(other)
+      self
+    end
+
+    def or_else(&block)
+      self
+    end
   end
 end

data/lib/deterministic/maybe.rb

@@ -1,56 +1,3 @@
-# The simplest NullObject there can be
-class None
-  class << self
-    def method_missing(m, *args)
-      if m == :new
-        super
-      else
-        None.instance.send(m, *args)
-      end
-    end
-
-    def instance
-      @instance ||= new([])
-    end
-
-    def mimic(klas)
-      new(klas.instance_methods(false))
-    end
-  end
-  private_class_method :new
-
-  def initialize(methods)
-    @methods = methods
-  end
-
-  # implicit conversions
-  def to_str
-    ''
-  end
-
-  def to_ary
-    []
-  end
-
-  def method_missing(m, *args)
-    return self if respond_to?(m)
-    super
-  end
-
-  def none?
-    true
-  end
-
-  def some?
-    false
-  end
-
-  def respond_to?(m)
-    return true if @methods.empty? || @methods.include?(m)
-    super
-  end
-end
-
 class Object
   def none?
     false

data/lib/deterministic/monad.rb

@@ -26,7 +26,7 @@ module Deterministic
     # the self.class, i.e. the containing monad is passed as a second (optional) arg to the function
     def bind(proc=nil, &block)
       (proc || block).call(value, self.class).tap do |result|
-        raise NotMonadError unless result.is_a? self.class
+        raise NotMonadError, "Expected #{result.inspect} to be an Either" unless result.is_a? self.class
       end
     end
     alias :'>>=' :bind

data/lib/deterministic/none.rb

@@ -0,0 +1,72 @@
+# The simplest NullObject there can be
+class None
+  class << self
+    def method_missing(m, *args)
+      if m == :new
+        super
+      else
+        None.instance.send(m, *args)
+      end
+    end
+
+    def instance
+      @instance ||= new([])
+    end
+
+    def none?
+      true
+    end
+
+    def some?
+      false
+    end
+
+    def mimic(klas)
+      new(klas.instance_methods(false))
+    end
+
+    def ==(other)
+      other.respond_to?(:none?) && other.none?
+    end
+  end
+  private_class_method :new
+
+  def initialize(methods)
+    @methods = methods
+  end
+
+  # implicit conversions
+  def to_str
+    ''
+  end
+
+  def to_ary
+    []
+  end
+
+  def method_missing(m, *args)
+    return self if respond_to?(m)
+    super
+  end
+
+  def none?
+    true
+  end
+
+  def some?
+    false
+  end
+
+  def respond_to?(m)
+    return true if @methods.empty? || @methods.include?(m)
+    super
+  end
+
+  def inspect
+    'None'
+  end
+
+  def ==(other)
+    other.respond_to?(:none?) && other.none?
+  end
+end

data/lib/deterministic/version.rb

@@ -1,3 +1,3 @@
 module Deterministic
-  VERSION = "0.5.2"
+  VERSION = "0.6.0"
 end

data/spec/lib/deterministic/either/failure_spec.rb

@@ -26,3 +26,30 @@ describe Deterministic::Failure do
     let(:either) { described_class }
   end
 end
+
+
+describe "Chaining" do
+  it "#or" do
+    expect(Success(1).or(Failure(2))).to eq Success(1)
+    expect(Failure(1).or(Success(2))).to eq Success(2)
+    expect { Failure(1).or(2) }.to raise_error(Deterministic::Monad::NotMonadError)
+  end
+
+  it "#or_else" do
+    expect(Success(1).or_else { Failure(2) }).to eq Success(1)
+    expect(Failure(1).or_else { |v| Success(v + 1) }).to eq Success(2)
+    expect { Failure(1).or_else { 2 } }.to raise_error(Deterministic::Monad::NotMonadError)
+  end
+
+  it "#and" do
+    expect(Success(1).and(Success(2))).to eq Success(2)
+    expect(Failure(1).and(Success(2))).to eq Failure(1)
+    expect { Success(1).and(2) }.to raise_error(Deterministic::Monad::NotMonadError)
+  end
+
+  it "#and_then" do
+    expect(Success(1).and_then { Success(2) }).to eq Success(2)
+    expect(Failure(1).and_then { Success(2) }).to eq Failure(1)
+    expect { Success(1).and_then { 2 } }.to raise_error(Deterministic::Monad::NotMonadError)
+  end
+end

data/spec/lib/deterministic/maybe_spec.rb

@@ -13,35 +13,4 @@ describe 'maybe' do
     expect(Maybe("a")).not_to be_none
   end
 
-  it "None is a Singleton" do
-    expect(None.instance).to be_a None
-    expect { None.new }.to raise_error(NoMethodError, "private method `new' called for None:Class")
-  end
-
-  it "implicit conversions" do
-    null = Maybe(nil)
-    expect(null.to_str).to eq ""
-    expect(null.to_ary).to eq []
-    expect("" + null).to eq ""
-
-    a, b, c = null
-    expect(a).to be_nil
-    expect(b).to be_nil
-    expect(c).to be_nil
-  end
-
-  it "explicit conversions" do
-    expect(None.to_s).to eq 'None'
-  end
-
-  it "mimic, only return None on specific methods of another class" do
-    class MimicTest
-      def test
-      end
-    end
-
-    mimic = None.mimic(MimicTest)
-    expect(mimic.test).to be_none
-    expect { mimic.foo }.to raise_error(NoMethodError)
-  end
 end

data/spec/lib/deterministic/none_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+require "deterministic/none"
+
+describe None do
+  it "None is a Singleton" do
+    expect(None.instance).to be_a None
+    expect { None.new }.to raise_error(NoMethodError, "private method `new' called for None:Class")
+  end
+
+  it "explicit conversions" do
+    expect(None.to_s).to eq 'None'
+    expect(None.inspect).to eq 'None'
+  end
+
+  it "compares to None" do
+    expect(None === None.instance).to be_truthy
+    expect(None.instance === None).to be_truthy
+    expect(None.instance).to eq None
+    expect(None).to eq None.instance
+    expect(1).not_to be None
+    expect(1).not_to be None.instance
+    expect(None.instance).not_to be 1
+    expect(None).not_to be 1
+    expect(None.instance).not_to be_nil
+    expect(None).not_to be_nil
+  end
+
+  it "implicit conversions" do
+    none = None.instance
+    expect(none.to_str).to eq ""
+    expect(none.to_ary).to eq []
+    expect("" + none).to eq ""
+
+    a, b, c = none
+    expect(a).to be_nil
+    expect(b).to be_nil
+    expect(c).to be_nil
+  end
+
+  it "mimicks other classes and returns None for their public methods" do
+    class UnderMimickTest
+      def test; end
+    end
+
+    mimick = None.mimic(UnderMimickTest)
+    expect(mimick.test).to be_none
+    expect { mimick.i_dont_exist}.to raise_error(NoMethodError)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deterministic
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Piotr Zolnierek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-29 00:00:00.000000000 Z
+date: 2014-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -134,6 +134,7 @@ files:
 - lib/deterministic/either/success.rb
 - lib/deterministic/maybe.rb
 - lib/deterministic/monad.rb
+- lib/deterministic/none.rb
 - lib/deterministic/version.rb
 - spec/examples/bookings_spec.rb
 - spec/examples/validate_address_spec.rb
@@ -148,6 +149,7 @@ files:
 - spec/lib/deterministic/maybe_spec.rb
 - spec/lib/deterministic/monad_axioms.rb
 - spec/lib/deterministic/monad_spec.rb
+- spec/lib/deterministic/none_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/pzol/deterministic
 licenses:
@@ -187,4 +189,5 @@ test_files:
 - spec/lib/deterministic/maybe_spec.rb
 - spec/lib/deterministic/monad_axioms.rb
 - spec/lib/deterministic/monad_spec.rb
+- spec/lib/deterministic/none_spec.rb
 - spec/spec_helper.rb