deterministic 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6ccf85126958f17b98ac22932b29ed508584250
-  data.tar.gz: 689d36f2f3b71bcc6192129514a8ca14b2b32001
+  metadata.gz: 02bcfb726015c3bfd566bb7ac4fa2ec7827f9916
+  data.tar.gz: 41febde66849c34ad23f4d031b0ca4cdd91b26fd
 SHA512:
-  metadata.gz: c3c067aab6e1418a829a72505ad33f5822d3f7c749ece67aa903c306e7910ab2158cf5005f439d3dceffe032394f321109fc618c892b4324e85a2a469c8de6eb
-  data.tar.gz: 9500d35aedd9849fd2893534b6a220256ac71696b973e86978b4d714233a17a31acd017efdd55cd0dee18afdd25522ab05a0f357e2023819784067fecce687b4
+  metadata.gz: 04113508f25059be7d25c184acedd3dfe20b9d2f2e267c5d7e5a62ee658f5049f11650da4d8a8565c4b1fccf9084b700ea6477fef32a3a36cf6b87face2136f8
+  data.tar.gz: 3c3bf38b691b39a7fd8f3a510738a9dbe8662796ccf509b20666f2d422f26452c70159e3291303eac44a9db62f142bba8ef08dd4e2cee1f65db6bf4184362f36

data/README.md

@@ -19,7 +19,7 @@ Failure(1).to_s                        # => "1"
 Failure(Failure(1))                    # => Failure(1)
 ```
 
-#### `fmap :: R a -> (a -> b) -> R b`
+#### `fmap(self: Result(a), op: |a| -> b) -> Result(b)`
 
 Maps a `Result` with the value `a` to the same `Result` with the value `b`.
 
@@ -28,7 +28,7 @@ Success(1).fmap { |v| v + 1}           # => Success(2)
 Failure(1).fmap { |v| v - 1}           # => Failure(0)
 ```
 
-#### `bind :: R a -> (a -> R b) -> R b`
+#### `bind(self: Result(a), op: |a| -> Result(b)) -> Result(b)`
 
 Maps a `Result` with the value `a` to another `Result` with the value `b`.
 
@@ -37,7 +37,7 @@ Success(1).bind { |v| Failure(v + 1) } # => Failure(2)
 Failure(1).fmap { |v| Success(v - 1) } # => Success(0)
 ```
 
-#### `map :: S a -> (a -> R b) -> R b`
+#### `map(self: Success(a), op: |a| -> Result(b)) -> Result(b)`
 
 Maps a `Success` with the value `a` to another `Result` with the value `b`. It works like `#bind` but only on `Success`.
 
@@ -46,7 +46,7 @@ Success(1).map { |n| n + 1 }           # => Success(2)
 Failure(0).map { |n| n + 1 }           # => Failure(0)
 ```
 
-#### `map_err :: F a -> (a -> R b) -> R b`
+#### `map_err(self: Failure(a), op: |a| -> Result(b)) -> Result(b)`
 
 Maps a `Failure` with the value `a` to another `Result` with the value `b`. It works like `#bind` but only on `Failure`.
 
@@ -55,7 +55,7 @@ Failure(1).map_err { |n| n + 1 } # => Success(2)
 Success(0).map_err { |n| n + 1 } # => Success(0)
 ```
 
-#### `try :: S a -> ( a -> R b) -> R b`
+#### `try(self: Success(a),  op: |a| -> Result(b)) -> Result(b)`
 
 Just like `#map`, transforms `a` to another `Result`, but it will also catch raised exceptions and wrap them with a `Failure`.
 
@@ -63,7 +63,7 @@ Just like `#map`, transforms `a` to another `Result`, but it will also catch rai
 Success(0).try { |n| raise "Error" }   # => Failure(Error)
 ```
 
-#### `and :: S a -> R b -> R b`
+#### `and(self: Success(a), other: Result(b)) -> Result(b)`
 
 Replaces `Success a` with `Result b`. If a `Failure` is passed as argument, it is ignored.
 
@@ -72,7 +72,7 @@ Success(1).and Success(2)            # => Success(2)
 Failure(1).and Success(2)            # => Failure(1)
 ```
 
-#### `and_then :: S a -> (a -> R b) -> R b`
+#### `and_then(self: Success(a), op: |a| -> Result(b)) -> Result(b)`
 
 Replaces `Success a` with the result of the block. If a `Failure` is passed as argument, it is ignored.
 
@@ -81,7 +81,7 @@ Success(1).and_then { Success(2) }   # => Success(2)
 Failure(1).and_then { Success(2) }   # => Failure(1)
 ```
 
-#### `or :: F a -> R b -> R b` 
+#### `or(self: Failure(a), other: Result(b)) -> Result(b)` 
 Replaces `Failure a` with `Result`. If a `Failure` is passed as argument, it is ignored.
 
 ```ruby
@@ -89,7 +89,7 @@ Success(1).or Success(2)             # => Success(1)
 Failure(1).or Success(1)             # => Success(1)
 ```
 
-#### `or_else :: F a -> (a -> R b) -> R b`
+#### `or_else(self: Failure(a),  op: |a| -> Result(b)) -> Result(b)`
 
 Replaces `Failure a` with the result of the block. If a `Success` is passed as argument, it is ignored.
 
@@ -98,7 +98,7 @@ Success(1).or_else { Success(2) }    # => Success(1)
 Failure(1).or_else { |n| Success(n)} # => Success(1)
 ```
 
-#### `pipe :: R a -> (R a -> b) -> R a`
+#### `pipe(self: Result(a), op: |Result(a)| -> b) -> Result(a)`
 
 Executes the block passed, but completely ignores its result. If an error is raised within the block it will **NOT** be catched.
 
@@ -269,16 +269,16 @@ Failure(1).result?  # => true
 
 
 ## Maybe
-The simplest NullObject wrapper there can be. It adds `#some?` and `#none?` to `Object` though.
+The simplest NullObject wrapper there can be. It adds `#some?` and `#null?` to `Object` though.
 
 ```ruby
 require 'deterministic/maybe' # you need to do this explicitly
-Maybe(nil).foo        # => None
-Maybe(nil).foo.bar    # => None
+Maybe(nil).foo        # => Null
+Maybe(nil).foo.bar    # => Null
 Maybe({a: 1})[:a]     # => 1
 
-Maybe(nil).none?      # => true
-Maybe({}).none?       # => false
+Maybe(nil).null?      # => true
+Maybe({}).null?       # => false
 
 Maybe(nil).some?      # => false
 Maybe({}).some?       # => true
@@ -293,9 +293,9 @@ class Mimick
   def test; end
 end
 
-null = Maybe.mimick(Mimick)
-null.test             # => None
-null.foo              # => NoMethodError
+naught = Maybe.mimick(Mimick)
+naught.test             # => Null
+naught.foo              # => NoMethodError
 ```
 
 ## Inspirations

data/lib/deterministic.rb

@@ -5,9 +5,8 @@ warn "WARN: Deterministic is meant to run on Ruby 2+" if RUBY_VERSION.to_f < 2
 module Deterministic; end
 
 require 'deterministic/monad'
-require 'deterministic/result/match'
+require 'deterministic/match'
 require 'deterministic/result/chain'
 require 'deterministic/result'
-require 'deterministic/result/success'
-require 'deterministic/result/failure'
-require 'deterministic/none'
+require 'deterministic/option'
+require 'deterministic/null'

data/lib/deterministic/core_ext/result.rb

@@ -4,11 +4,11 @@ module Deterministic
   module CoreExt
     module Result
       def success?
-        self.is_a? Success
+        self.is_a? Deterministic::Result::Success
       end
 
       def failure?
-        self.is_a? Failure
+        self.is_a? Deterministic::Result::Failure
       end
 
       def result?

data/lib/deterministic/match.rb

@@ -0,0 +1,60 @@
+module Deterministic
+  module PatternMatching
+
+    def match(context=nil, &block)
+      context ||= block.binding.eval('self') # the instance containing the match block
+      match = binding.eval('self.class::Match.new(self, context)') # the class defining the Match
+      match.instance_eval &block
+      match.call
+    end
+
+    class NoMatchError < StandardError; end
+
+    module Match
+      def initialize(container, context)
+        @container  = container
+        @context    = context
+        @collection = []
+      end
+
+      def call
+        matcher = @collection.detect { |m| m.matches?(@container.value) }
+        raise NoMatchError, "No match could be made for #{@container.inspect}" if matcher.nil?
+        @context.instance_exec(@container.value, &matcher.block)
+      end
+
+      # catch-all
+      def any(value=nil, &result_block)
+        push(Object, value, result_block)
+      end
+
+    private
+      Matcher = Struct.new(:condition, :block) do
+        def matches?(value)
+          condition.call(value)
+        end
+      end
+
+      def push(type, condition, result_block)
+        condition_pred = case
+        when condition.nil?;          ->(v) { true }
+        when condition.is_a?(Proc);   condition
+        when condition.is_a?(Class);  ->(v) { condition === @container.value }
+        else                          ->(v) { @container.value == condition }
+        end
+
+        matcher_pred = compose_predicates(type_pred[type], condition_pred)
+        @collection << Matcher.new(matcher_pred, result_block)
+      end
+
+      def compose_predicates(f, g)
+        ->(*args) { f[*args] && g[*args] }
+      end
+
+      # return a partial function for matching a matcher's type
+      def type_pred
+        (->(type, x) { @container.is_a? type }).curry
+      end
+    end
+  end
+end

data/lib/deterministic/maybe.rb

@@ -1,5 +1,5 @@
 class Object
-  def none?
+  def null?
     false
   end
 
@@ -9,5 +9,5 @@ class Object
 end
 
 def Maybe(obj)
-  obj.nil? ? None.instance : obj
+  obj.nil? ? Null.instance : obj
 end

data/lib/deterministic/monad.rb

@@ -25,8 +25,9 @@ module Deterministic
     # bind :: (a -> Mb) -> M a  -> M b
     # 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, "Expected #{result.inspect} to be an Result" unless result.is_a? self.class
+      (proc || block).call(value).tap do |result|
+        parent = self.class.superclass === Object ? self.class : self.class.superclass
+        raise NotMonadError, "Expected #{result.inspect} to be an #{parent}" unless result.is_a? parent
       end
     end
     alias :'>>=' :bind
@@ -37,6 +38,15 @@ module Deterministic
       @value
     end
 
+    def to_s
+      value.to_s
+    end
+
+    def inspect
+      name = self.class.name.split("::")[-1]
+      "#{name}(#{value})"
+    end
+
     # Two monads are equivalent if they are of the same type and when their values are equal
     def ==(other)
       return false unless other.is_a? self.class
@@ -44,7 +54,7 @@ module Deterministic
     end
 
     # Return the string representation of the Monad
-    def to_s
+    def inspect
       pretty_class_name = self.class.name.split('::')[-1]
       "#{pretty_class_name}(#{self.value.inspect})"
     end

data/lib/deterministic/{none.rb → null.rb}

@@ -1,11 +1,11 @@
 # The simplest NullObject there can be
-class None
+class Null
   class << self
     def method_missing(m, *args)
       if m == :new
         super
       else
-        None.instance
+        Null.instance
       end
     end
 
@@ -13,7 +13,7 @@ class None
       @instance ||= new([])
     end
 
-    def none?
+    def null?
       true
     end
 
@@ -26,7 +26,7 @@ class None
     end
 
     def ==(other)
-      other.respond_to?(:none?) && other.none?
+      other.respond_to?(:null?) && other.null?
     end
   end
   private_class_method :new
@@ -49,7 +49,7 @@ class None
     super
   end
 
-  def none?
+  def null?
     true
   end
 
@@ -63,10 +63,10 @@ class None
   end
 
   def inspect
-    'None'
+    'Null'
   end
 
   def ==(other)
-    other.respond_to?(:none?) && other.none?
+    other.respond_to?(:null?) && other.null?
   end
 end

data/lib/deterministic/option.rb

@@ -0,0 +1,95 @@
+module Deterministic
+  # Abstract parent of Some and None 
+  class Option
+    include Monad
+
+    module PatternMatching
+      include Deterministic::PatternMatching
+      class Match
+        include Deterministic::PatternMatching::Match
+
+        %w[Some None Option].each do |s|
+          define_method s.downcase.to_sym do |value=nil, &block|
+            klas = Module.const_get("Deterministic::Option::#{s}")
+            push(klas, value, block)
+          end
+        end
+      end
+    end
+
+    include PatternMatching
+
+    # This is an abstract class, can't ever instantiate it directly
+    class << self
+      protected :new
+
+      def some?(expr)
+        to_option(expr) { expr.nil? }
+      end
+
+      def any?(expr)
+        to_option(expr) { expr.nil? || not(expr.respond_to?(:empty?)) || expr.empty? }
+      end
+
+      def to_option(expr, &predicate)
+        predicate.call(expr) ? None.new : Some.new(expr)
+      end
+
+      def try!
+        yield rescue None.new
+      end
+    end
+
+    def map(proc=nil, &block)
+      return self if none?
+      bind(proc || block)
+    end
+
+    def some?
+      is_a? Some
+    end
+
+    def none?
+      is_a? None
+    end
+
+    class Some < Option
+      class << self; public :new; end
+    end
+
+    class None < Option
+      class << self; public :new; end
+      def initialize(*args); end
+
+      def inspect
+        "None"
+      end
+
+      # def value
+      #   self
+      # end
+      def none(*args)
+        self
+      end
+
+      alias :fmap :none
+      alias :map :none
+
+      def ==(other)
+        other.class == self.class
+      end
+
+      # def value
+      #   self # raise "value called on a None"
+      # end
+    end
+  end
+
+module_function
+  def Some(value)
+    Option::Some.new(value)
+  end
+
+  None = Deterministic::Option::None.new
+end
+# p Deterministic::Option::Some::Match.new(.methods

data/lib/deterministic/result.rb

@@ -2,15 +2,24 @@ module Deterministic
   # Abstract parent of Success and Failure
   class Result
     include Monad
-    include Deterministic::PatternMatching
-    include Chain
 
-    def bind(proc=nil, &block)
-      (proc || block).call(value).tap do |result|
-        raise NotMonadError, "Expected #{result.inspect} to be an Result" unless result.is_a? self.class.superclass
+    module PatternMatching
+      include Deterministic::PatternMatching
+      class Match
+        include Deterministic::PatternMatching::Match
+
+        %w[Success Failure Result].each do |s|
+          define_method s.downcase.to_sym do |value=nil, &block|
+            klas = Module.const_get("Deterministic::Result::#{s}")
+            push(klas, value, block)
+          end
+        end
       end
     end
 
+    include PatternMatching
+    include Chain
+
     def success?
       is_a? Success
     end
@@ -52,23 +61,22 @@ module Deterministic
     class << self
       protected :new
     end
-
-    def to_s
-      value.to_s
+    
+    class Failure < Result
+      class << self; public :new; end
     end
-
-    def inspect
-      name = self.class.name.split("::")[-1]
-      "#{name}(#{value})"
+    
+    class Success < Result
+      class << self; public :new; end
     end
   end
 
 module_function
   def Success(value)
-    Success.new(value)
+    Result::Success.new(value)
   end
 
   def Failure(value)
-    Failure.new(value)
+    Result::Failure.new(value)
   end
 end

data/lib/deterministic/version.rb

@@ -1,3 +1,3 @@
 module Deterministic
-  VERSION = "0.10.0"
+  VERSION = "0.12.0"
 end

data/spec/examples/config_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+include Deterministic
+
+class ElasticSearchConfig
+  def initialize(env="development", proc_env=ENV)
+    @env, @proc_env = env, proc_env
+  end
+
+  attr_reader :env
+
+  def hosts
+    Option.any?(proc_env["RESFINITY_LOG_CLIENT_ES_HOST"]).match {
+      some { |s| { hosts: s.split(/, */) } }
+      none { default_hosts }
+    }
+  end
+
+private
+  attr_reader :proc_env
+  def default_hosts
+    case env
+    when "production"
+      { hosts: ["resfinity.net:9200"] }
+    when "acceptance" ||  "development"
+      { hosts: ["acc.resfinity.net:9200"] }
+    else
+      { hosts: ["localhost:9200"] }
+    end
+  end
+end
+
+describe ElasticSearchConfig do
+  let(:cfg) { ElasticSearchConfig.new(environment, env) }
+  context "test" do
+    let(:environment) { "test" }
+    context "env empty" do
+      let(:env) { {} }
+      specify { expect(cfg.hosts).to eq({ hosts: ["localhost:9200"] }) }
+    end
+
+    context "env empty" do
+      let(:env) { { "RESFINITY_LOG_CLIENT_ES_HOST" => "" } }
+      specify { expect(cfg.hosts).to eq({ hosts: ["localhost:9200"] }) }
+    end
+
+    context "env contains one" do
+      let(:env) { { "RESFINITY_LOG_CLIENT_ES_HOST" => "foo:9999"} }
+      specify { expect(cfg.hosts).to eq({ hosts: ["foo:9999"] }) }
+    end
+
+    context "env contains two" do
+      let(:env) { { "RESFINITY_LOG_CLIENT_ES_HOST" => "foo:9999,bar:9200"} }
+      specify { expect(cfg.hosts).to eq({ hosts: ["foo:9999", "bar:9200"] }) }
+    end
+  end
+
+  context "production" do
+    let(:environment) { "production" }
+    context "env empty" do
+      let(:env) { {} }
+      specify { expect(cfg.hosts).to eq({ hosts: ["resfinity.net:9200"] }) }
+    end
+  end
+
+  context "acceptance" do
+    let(:environment) { "acceptance" }
+    context "env empty" do
+      let(:env) { {} }
+      specify { expect(cfg.hosts).to eq({ hosts: ["acc.resfinity.net:9200"] }) }
+    end
+  end
+end

data/spec/examples/validate_address_spec.rb

@@ -19,13 +19,13 @@ describe ValidateAddress do
   subject { ValidateAddress.call(candidate)  }
   context 'sunny day' do
     let(:candidate) { {title: "Hobbiton", street: "501 Buckland Rd", city: "Matamata", postal: "3472", country: "nz"} }
-    specify { expect(subject).to be_a Success }
+    specify { expect(subject).to be_a Result::Success }
     specify { expect(subject.value).to eq candidate }
   end
 
   context 'empty data' do
     let(:candidate) { {} }
-    specify { expect(subject).to be_a Failure }
+    specify { expect(subject).to be_a Result::Failure }
     specify { expect(subject.value).to include(:street, :city, :postal) }
   end
 end

data/spec/lib/deterministic/maybe_spec.rb

@@ -3,16 +3,16 @@ require 'deterministic/maybe'
 
 describe 'maybe' do
   it "does something" do
-    expect(Maybe(nil).foo).to be_none
-    expect(Maybe(nil).foo.bar.baz).to be_none
-    expect(Maybe(nil).fetch(:a)).to be_none
+    expect(Maybe(nil).foo).to be_null
+    expect(Maybe(nil).foo.bar.baz).to be_null
+    expect(Maybe(nil).fetch(:a)).to be_null
     expect(Maybe(1)).to be_some
     expect(Maybe({a: 1}).fetch(:a)).to eq 1
     expect(Maybe({a: 1})[:a]).to eq 1
     expect(Maybe("a").upcase).to eq "A"
-    expect(Maybe("a")).not_to be_none
+    expect(Maybe("a")).not_to be_null
 
-    # expect(Maybe[[]]).to eq be_none
+    # expect(Maybe[[]]).to eq be_null
   end
 
 end

data/spec/lib/deterministic/monad_spec.rb

@@ -7,12 +7,15 @@ describe Deterministic::Monad do
     include Deterministic::Monad
   end
 
+  let(:monad) { Identity }
   it_behaves_like 'a Monad' do 
-    let(:monad) { Identity }
+    # let(:monad) { monad }
   end
 
-  specify { expect(Identity.new(1).to_s).to  eq 'Identity(1)' }
-  specify { expect(Identity.new(nil).to_s).to  eq 'Identity(nil)' }
+  specify { expect(Identity.new(1).inspect).to  eq 'Identity(1)' }
+  specify { expect(Identity.new(1).to_s).to  eq '1' }
+  specify { expect(Identity.new(nil).inspect).to  eq 'Identity(nil)' }
+  specify { expect(Identity.new(nil).to_s).to  eq '' }
   specify { expect(Identity.new([1, 2]).fmap(&:to_s)).to eq Identity.new("[1, 2]") }
   specify { expect(Identity.new(1).fmap {|v| v + 2}).to eq Identity.new(3) }
   specify { expect(Identity.new('foo').fmap(&:upcase)).to eq Identity.new('FOO')}
@@ -25,24 +28,17 @@ describe Deterministic::Monad do
 
     it "passes the monad class, this is ruby-fu?!" do
      Identity.new(1)
-      .bind do |_, monad|
+      .bind do |_|
         expect(monad).to eq Identity
         monad.new(_)
       end
     end
 
     specify { expect(
-      Identity.new(1).bind { |value, monad| monad.new(value + 1) }
+      monad.new(1).bind { |value| monad.new(value + 1) }
       ).to eq Identity.new(2)
     }
 
   end
   specify { expect(Identity.new(Identity.new(1))).to eq Identity.new(1) }
-
-  # it 'delegates #flat_map to an underlying collection and wraps the resulting collection' do
-  #   Identity.unit([1,2]).flat_map {|v| v + 1}.should == Identity.unit([2, 3])
-  #   Identity.unit(['foo', 'bar']).flat_map(&:upcase).should == Identity.unit(['FOO', 'BAR'])
-  #   expect { Identity.unit(1).flat_map {|v| v + 1 } }.to raise_error(RuntimeError)
-  # end
-
 end

data/spec/lib/deterministic/null_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+require "deterministic/null"
+
+describe Null do
+  it "Null is a Singleton" do
+    expect(Null.instance).to be_a Null
+    expect { Null.new }.to raise_error(NoMethodError, "private method `new' called for Null:Class")
+  end
+
+  it "explicit conversions" do
+    expect(Null.to_s).to eq 'Null'
+    expect(Null.inspect).to eq 'Null'
+  end
+
+  it "compares to Null" do
+    expect(Null === Null.instance).to be_truthy
+    expect(Null.instance === Null).to be_truthy
+    expect(Null.instance).to eq Null
+    expect(Null).to eq Null.instance
+    expect(1).not_to be Null
+    expect(1).not_to be Null.instance
+    expect(Null.instance).not_to be 1
+    expect(Null).not_to be 1
+    expect(Null.instance).not_to be_nil
+    expect(Null).not_to be_nil
+  end
+
+  it "implicit conversions" do
+    null = Null.instance
+    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 "mimicks other classes and returns Null for their public methods" do
+    class UnderMimickTest
+      def test; end
+    end
+
+    mimick = Null.mimic(UnderMimickTest)
+    expect(mimick.test).to be_null
+    expect { mimick.i_dont_exist}.to raise_error(NoMethodError)
+  end
+end

data/spec/lib/deterministic/option_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require_relative 'monad_axioms'
+
+include Deterministic
+
+describe Deterministic::Option do
+  # nil?
+  specify { expect(described_class.some?(nil)).to eq None }
+  specify { expect(described_class.some?(1)).to be_some }
+  specify { expect(described_class.some?(1)).to eq Some(1) }
+
+  # any?
+  specify { expect(described_class.any?(nil)).to be_none }
+  specify { expect(described_class.any?("")).to  be_none }
+  specify { expect(described_class.any?([])).to  be_none }
+  specify { expect(described_class.any?({})).to  be_none }
+  specify { expect(described_class.any?([1])).to eq Some([1]) }
+  specify { expect(described_class.any?({foo: 1})).to eq Some({foo: 1}) }
+
+  # try!
+  specify { expect(described_class.try! { raise "error" }).to be_none }
+end
+
+describe Deterministic::Option::Some do
+   it_behaves_like 'a Monad' do
+    let(:monad) { described_class }
+  end
+
+  specify { expect(described_class.new(0)).to be_a Option::Some }
+  specify { expect(described_class.new(0)).to eq Some(0) }
+  specify { expect(described_class.new(0).some?).to be_truthy }
+  specify { expect(described_class.new(0).none?).to be_falsey }
+  specify { expect(described_class.new(0).value).to eq 0 }
+
+  specify { expect(described_class.new(1).fmap { |n| n + 1}).to eq Some(2) }
+  specify { expect(described_class.new(1).map { |n| Some(n + 1)}).to eq Some(2) }
+  specify { expect(described_class.new(1).map { |n| None }).to eq None }
+
+  specify {
+    expect(
+      Some(0).match {
+        some(1) { |n| 99 }
+        some(0) { |n| n + 1 }
+        none(1) {}
+      }
+    ).to eq 1
+  }
+
+  specify {
+    expect(
+      Some(nil).match {
+        none { 0 }
+        some { 1 }
+      }
+    ).to eq 1
+  }
+
+  specify {
+    expect(
+      Some(1).match {
+        none { 0 }
+        some(Fixnum) { 1 }
+      }
+    ).to eq 1
+  }
+
+  specify {
+    expect(
+      None.match {
+        none { 0 }
+        some { 1 }
+      }
+    ).to eq 0
+  }
+
+end
+
+describe Deterministic::Option::None do
+  #  it_behaves_like 'a Monad' do
+  #   let(:monad) { described_class }
+  # end
+
+  specify { expect(described_class.new).to eq None }
+  specify { expect(described_class.new.some?).to be_falsey }
+  specify { expect(described_class.new.none?).to be_truthy }
+  # specify { expect { described_class.new.value }.to raise_error RuntimeError }
+
+  specify { expect(described_class.new.fmap { |n| n + 1}).to eq None }
+  specify { expect(described_class.new.map { |n| nil }).to eq None }
+  specify { expect(described_class.new).to eq Option::None.new }
+  specify { expect(described_class.new).to eq None }
+end

data/spec/lib/deterministic/result/chain_spec.rb

@@ -95,7 +95,7 @@ describe Deterministic::Result do
         Success(self)
       end
 
-      def to_s
+      def inspect
         "Step #{@step}"
       end
 
@@ -114,7 +114,7 @@ describe Deterministic::Result do
 
     it "works" do
       test = SelfContextUnderTest.new.call
-      expect(test).to be_a Success
+      expect(test).to be_a described_class::Success
       expect(test.inspect).to eq "Success(Step 3)"
     end
   end
@@ -144,7 +144,7 @@ describe Deterministic::Result do
       end
 
       actual = Success(1) >= method(:error)
-      expect(actual.inspect).to eq "Failure(error 1)"
+      expect(actual.inspect).to eq "Failure(#<RuntimeError: error 1>)"
     end
   end
 end

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

@@ -4,7 +4,7 @@ require_relative 'result_shared'
 
 include Deterministic
 
-describe Deterministic::Failure do
+describe Deterministic::Result::Failure do
 
   it_behaves_like 'a Monad' do
     let(:monad) { described_class }
@@ -15,6 +15,8 @@ describe Deterministic::Failure do
   specify { expect(subject).to be_an_instance_of described_class }
   specify { expect(subject).to be_failure }
   specify { expect(subject).not_to be_success }
+  specify { expect(subject.success?).to be_falsey }
+  specify { expect(subject.failure?).to be_truthy }
 
   specify { expect(subject).to be_an_instance_of described_class }
   specify { expect(subject).to eq(described_class.new(1)) }

data/spec/lib/deterministic/result/match_spec.rb

@@ -104,7 +104,7 @@ describe Deterministic::Result::Match do
 
     expect(
       Failure(error_hash).match do
-        failure(:nothing) {|v| raise "We should not get to this point" }
+        failure(:null) {|v| raise "We should not get to this point" }
         failure(:needs_more_salt) do |error|
           "Successfully failed with #{error[:arbitrary]}!"
         end

data/spec/lib/deterministic/result/success_spec.rb

@@ -4,7 +4,7 @@ require_relative 'result_shared'
 
 include Deterministic
 
-describe Deterministic::Success do
+describe Deterministic::Result::Success do
 
   it_behaves_like 'a Monad' do
     let(:monad) { described_class }
@@ -15,6 +15,8 @@ describe Deterministic::Success do
   specify { expect(subject).to be_an_instance_of described_class }
   specify { expect(subject).to be_success }
   specify { expect(subject).not_to be_failure }
+  specify { expect(subject.success?).to be_truthy }
+  specify { expect(subject.failure?).to be_falsey }
 
   specify { expect(subject).to be_an_instance_of described_class }
   specify { expect(subject).to eq(described_class.new(1)) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deterministic
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Piotr Zolnierek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-25 00:00:00.000000000 Z
+date: 2014-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -127,23 +127,24 @@ files:
 - lib/deterministic.rb
 - lib/deterministic/core_ext/object/result.rb
 - lib/deterministic/core_ext/result.rb
+- lib/deterministic/match.rb
 - lib/deterministic/maybe.rb
 - lib/deterministic/monad.rb
-- lib/deterministic/none.rb
+- lib/deterministic/null.rb
+- lib/deterministic/option.rb
 - lib/deterministic/result.rb
 - lib/deterministic/result/chain.rb
-- lib/deterministic/result/failure.rb
-- lib/deterministic/result/match.rb
-- lib/deterministic/result/success.rb
 - lib/deterministic/version.rb
 - spec/examples/bookings_spec.rb
+- spec/examples/config_spec.rb
 - spec/examples/validate_address_spec.rb
 - spec/lib/deterministic/core_ext/object/either_spec.rb
 - spec/lib/deterministic/core_ext/result_spec.rb
 - 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/lib/deterministic/null_spec.rb
+- spec/lib/deterministic/option_spec.rb
 - spec/lib/deterministic/result/chain_spec.rb
 - spec/lib/deterministic/result/failure_spec.rb
 - spec/lib/deterministic/result/match_spec.rb
@@ -177,13 +178,15 @@ specification_version: 4
 summary: see above
 test_files:
 - spec/examples/bookings_spec.rb
+- spec/examples/config_spec.rb
 - spec/examples/validate_address_spec.rb
 - spec/lib/deterministic/core_ext/object/either_spec.rb
 - spec/lib/deterministic/core_ext/result_spec.rb
 - 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/lib/deterministic/null_spec.rb
+- spec/lib/deterministic/option_spec.rb
 - spec/lib/deterministic/result/chain_spec.rb
 - spec/lib/deterministic/result/failure_spec.rb
 - spec/lib/deterministic/result/match_spec.rb

data/lib/deterministic/result/failure.rb

@@ -1,5 +0,0 @@
-module Deterministic
-  class Failure < Result
-    class << self; public :new; end
-  end
-end

data/lib/deterministic/result/match.rb

@@ -1,66 +0,0 @@
-module Deterministic::PatternMatching
-
-  def match(context=nil, &block)
-    context ||= block.binding.eval('self')
-    match = Match.new(self, context)
-    match.instance_eval &block
-    match.call
-  end
-
-  class NoMatchError < StandardError; end
-
-  class Match
-    def initialize(container, context)
-      @container  = container
-      @context    = context
-      @collection = []
-    end
-
-    def call
-      matcher = @collection.detect { |m| m.matches?(@container.value) }
-      raise NoMatchError, "No match could be made for #{@container.inspect}" if matcher.nil?
-      @context.instance_exec(@container.value, &matcher.block)
-    end
-
-    # TODO: Result specific DSL, will need to move it to Result, later on
-    %w[Success Failure Result].each do |s|
-      define_method s.downcase.to_sym do |value=nil, &block|
-        klas = Module.const_get(s)
-        push(klas, value, block)
-      end
-    end
-
-    # catch-all
-    def any(value=nil, &result_block)
-      push(Object, value, result_block)
-    end
-
-  private
-    Matcher = Struct.new(:condition, :block) do
-      def matches?(value)
-        condition.call(value)
-      end
-    end
-
-    def push(type, condition, result_block)
-      condition_pred = case
-      when condition.nil?;          ->(v) { true }
-      when condition.is_a?(Proc);   condition
-      when condition.is_a?(Class);  ->(v) { condition === @container.value }
-      else                          ->(v) { @container.value == condition }
-      end
-
-      matcher_pred = compose_predicates(type_pred[type], condition_pred)
-      @collection << Matcher.new(matcher_pred, result_block)
-    end
-
-    def compose_predicates(f, g)
-      ->(*args) { f[*args] && g[*args] }
-    end
-
-    # return a partial function for matching a matcher's type
-    def type_pred
-      (->(type, x) { @container.is_a? type }).curry
-    end
-  end
-end

data/lib/deterministic/result/success.rb

@@ -1,5 +0,0 @@
-module Deterministic
-  class Success < Result
-    class << self; public :new; end
-  end
-end

data/spec/lib/deterministic/none_spec.rb

@@ -1,49 +0,0 @@
-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