deterministic 0.14.1 → 0.15.0

data/spec/examples/logger_spec.rb

@@ -17,7 +17,7 @@ class Logger
     def validate(item)
       return Failure(["Item cannot be empty"]) if item.blank?
       return Failure(["Item must be a Hash"]) unless item.is_a?(Hash)
- 
+
       validate_required_params(item).match {
          none { Success(item) }
          some { |errors| Failure(errors) }
@@ -46,7 +46,11 @@ class Logger
 class Ensure
   include Deterministic
   include Deterministic::Monad
-  None = Deterministic::Option::None.instance
+
+  None = Deterministic::Option::None.new
+  def Some(value)
+    Option::Some.new(value)
+  end
 
   attr_accessor :value
 
@@ -81,34 +85,35 @@ class Ensure
 end
 
 class Validator < Ensure
-  
+
   def date_is_one!
     value[:date] == 1 ? None : Some({actual: value[:date], expected: 1})
   end
 
   def required_params!
     params = %w(date tenant contract user facility short data)
-    params.inject(None) { |errors, param| 
+    params.inject(None) { |errors, param|
       errors + (value[:param].nil? || value[:param].empty? ? Some([param]) : None)
     }
   end
 
   def call
-    not_empty + is_a(Array) + None + has_key(:tenant) + Some("error").value_to_a + date_is_one + required_params
+    not_empty + is_a(Array) + None + has_key(:tenant) + Some(["error"]) #+ date_is_one + required_params
   end
 
 end
 
 describe Ensure do
-  # None = Deterministic::Option::None.instance
-  
+  None = Deterministic::Option::None.new
+  Some = Deterministic::Option::Some
+
   it "Ensure" do
     params = {date: 2}
 
     v = Validator.new(params)
 
     errors = v.call
-    expect(errors).to be_a Deterministic::Some
+    expect(errors).to be_a Some
     expect(errors.value).not_to be_empty
   end
 end

data/spec/examples/validate_address_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
-require 'deterministic'
 
-include Deterministic
 
 # A Unit of Work for validating an address
 module ValidateAddress
+  extend Deterministic::Prelude::Result
+
   def self.call(candidate)
     errors = {}
     errors[:street] = "Street cannot be empty" unless candidate.has_key? :street
@@ -16,16 +16,17 @@ module ValidateAddress
 end
 
 describe ValidateAddress do
+  include Deterministic
   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 Result::Success }
+    specify { expect(subject).to be_a Deterministic::Result::Success }
     specify { expect(subject.value).to eq candidate }
   end
 
   context 'empty data' do
     let(:candidate) { {} }
-    specify { expect(subject).to be_a Result::Failure }
+    specify { expect(subject).to be_a Deterministic::Result::Failure }
     specify { expect(subject.value).to include(:street, :city, :postal) }
   end
 end

data/spec/lib/deterministic/class_mixin_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 
 describe 'Class Mixin' do
-
   describe 'try' do
     module MyApp
       class Thing
-        include Deterministic
+        include Deterministic::Prelude::Result
 
         def run
-          Success(11) >= method(:double)
+          Success(11) >> method(:double)
         end
 
         def double(num)
@@ -19,7 +18,7 @@ describe 'Class Mixin' do
 
     it "cleanly mixes into a class" do
       result = MyApp::Thing.new.run
-      expect(result).to eq Deterministic::Success.new(22)
+      expect(result).to eq Deterministic::Result::Success.new(22)
     end
   end
 end

data/spec/lib/deterministic/core_ext/result_spec.rb

@@ -3,6 +3,8 @@ require "deterministic"
 require "deterministic/core_ext/result"
 
 describe Deterministic::CoreExt::Result do
+  include Deterministic::Prelude::Result
+
   it "does something" do
     h = {}
     h.extend(Deterministic::CoreExt::Result)
@@ -12,10 +14,10 @@ describe Deterministic::CoreExt::Result do
   end
 
   it "enables #success?, #failure?, #result? on all Objects" do
-    ary = [Deterministic::Success(true), Deterministic::Success(1)]
+    ary = [Success(true), Success(1)]
     expect(ary.all?(&:success?)).to be_truthy
 
-    ary = [Deterministic::Success(true), Deterministic::Failure(1)]
+    ary = [Success(true), Failure(1)]
     expect(ary.all?(&:success?)).to be_falsey
     expect(ary.any?(&:failure?)).to be_truthy
   end

data/spec/lib/deterministic/currify_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module Deterministic
+  module Currify
+    module ClassMethods
+      def currify(*names)
+        names.each { |name|
+          unbound_method = instance_method(name)
+
+          define_method(name) { |*args|
+            curried_method = unbound_method.bind(self).to_proc.curry
+            curried_method[*args]
+          }
+        }
+      end
+    end
+
+    def self.included(curried)
+      curried.extend ClassMethods
+    end
+
+  end
+end
+
+class ::Proc
+  def self.compose(f, g)
+    lambda { |*args| f[g[*args]] }
+  end
+
+  # Compose left to right
+  def |(g)
+    Proc.compose(g, self)
+  end
+
+  # Compose right to left
+  def *(g)
+    Proc.compose(self, g)
+  end
+end
+
+class Booking
+  include Deterministic::Currify
+  include Deterministic::Prelude::Result
+
+  def initialize(deps)
+    @deps = deps
+  end
+
+  def build(id, format)
+    validate(id) | req | find | render(format)
+
+    validate(id) | rq = request(id) | find()
+  end
+
+  def validate(id)
+    p [:validate, id]
+    Success(id)
+  end
+
+  def req(a, id)
+    p [:req, a, id]
+    Success(id: id + a)
+  end
+
+  def find(req)
+    Success({ found: req})
+  end
+
+  def render(format, req)
+    Success("rendered in #{format}: #{req[:found]}")
+  end
+
+  currify :find, :render, :req
+
+end
+
+describe "Pref" do
+  include Deterministic::Prelude::Result
+
+  it "does something" do
+    b = Booking.new(1)
+    actual = b.validate(1) >> b.req(2) >> b.find >> b.render(:html)
+
+    p [:actual, actual]
+    expected = Deterministic::Result::Success.new("rendered in html: {:id=>3}")
+    expect(actual).to eq expected
+  end
+end

data/spec/lib/deterministic/monad_spec.rb

@@ -3,12 +3,12 @@ require_relative 'monad_axioms'
 
 
 describe Deterministic::Monad do
-  class Identity 
+  class Identity
     include Deterministic::Monad
   end
 
   let(:monad) { Identity }
-  it_behaves_like 'a Monad' do 
+  it_behaves_like 'a Monad' do
     # let(:monad) { monad }
   end
 
@@ -21,7 +21,7 @@ describe Deterministic::Monad do
   specify { expect(Identity.new('foo').fmap(&:upcase)).to eq Identity.new('FOO')}
 
   context '#bind' do
-    it "raises an error if the passed function does not return a monad of the same class" do 
+    it "raises an error if the passed function does not return a monad of the same class" do
       expect { Identity.new(1).bind {} }.to raise_error(Deterministic::Monad::NotMonadError)
     end
     specify { expect(Identity.new(1).bind {|value| Identity.new(value) }).to eq Identity.new(1) }

data/spec/lib/deterministic/option_spec.rb

@@ -1,131 +1,140 @@
 require 'spec_helper'
-require_relative 'monad_axioms'
 
+include Deterministic
 
 describe Deterministic::Option do
-  include Deterministic
-  Some = Deterministic::Some
-  None = Deterministic::None
-
-  # 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?(None)).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
+  include Deterministic::Prelude::Option
+  None = Deterministic::Prelude::Option::None
 
-describe Deterministic::Option do
-  include Deterministic
-  Option = Deterministic::Option
-
-  #  it_behaves_like 'a Monad' do
-  #   let(:monad) { described_class }
-  # end
-
-  specify { expect(Option::Some.new(0)).to be_a Option::Some }
-  specify { expect(Option::Some.new(0)).to eq Some(0) }
-
-  specify { expect(Option::None.new).to eq Option::None.new }
-  specify { expect(Option::None.new).to eq None }
-
-  # some?, none?
-  specify { expect(None.some?).to be_falsey }
-  specify { expect(None.none?).to be_truthy }
-  specify { expect(Some(0).some?).to be_truthy }
-  specify { expect(Some(0).none?).to be_falsey }
-
-  # value, value_or
-  specify { expect(Some(0).value).to eq 0 }
-  specify { expect(Some(1).value_or(2)).to eq 1}
-  specify { expect { None.value }.to raise_error NoMethodError }
-  specify { expect(None.value_or(2)).to eq 2}
-
-  # fmap
-  specify { expect(Some(1).fmap { |n| n + 1}).to eq Some(2) }
-  specify { expect(None.fmap { |n| n + 1}).to eq None }
-
-  # map
-  specify { expect(Some(1).map { |n| Some(n + 1)}).to eq Some(2) }
-  specify { expect(Some(1).map { |n| None }).to eq None }
-  specify { expect(None.map { |n| nil }).to eq None }
-
-  # to_a
-  specify { expect(Some(1).value_to_a). to eq Some([1])}
-  specify { expect(Some([1]).value_to_a). to eq Some([1])}
-  specify { expect(None.value_to_a). to eq None}
-
-  # +
-  specify { expect(Some(1) + None).to eq Some(1) }
-  specify { expect(Some(1) + None + None).to eq Some(1) }
-  specify { expect(Some(1) + Some(1)).to eq Some(2) }
-  specify { expect(None + Some(1)).to eq Some(1) }
-  specify { expect(None + None + Some(1)).to eq Some(1) }
-  specify { expect(None + None + Some(1) + None).to eq Some(1) }
-  specify { expect { Some([1]) + Some(1)}.to raise_error TypeError}
-
-  # match
-  specify {
+  specify { expect(described_class::Some.new(0)).to be_a described_class::Some }
+  specify { expect(described_class::Some.new(0)).to be_a described_class }
+  specify { expect(described_class::Some.new(0)).to eq Some(0) }
+
+  specify { expect(described_class::None.new).to eq described_class::None.new }
+  specify { expect(described_class::None.new).to be_a described_class::None }
+  specify { expect(described_class::None.new).to be_a described_class }
+  specify { expect(described_class::None.new).to eq None }
+
+  it "join" do
+    expect(Some(Some(1))).to eq Some(1)
+  end
+
+  it "fmap" do
+    expect(Some(1).fmap { |n| n + 1}).to eq Some(2)
+    expect(None.fmap { |n| n + 1}).to eq None
+  end
+
+  it "map" do
+    expect(Some(1).map { |n| Some(n + 1)}).to eq Some(2)
+    expect(Some(1).map { |n| None }).to eq None
+    expect(None.map { |n| Some(n + 1)}).to eq None
+  end
+
+  it "some?" do
+    expect(Some(1).some?).to be_truthy
+    expect(None.some?).to be_falsey
+  end
+
+  it "none?" do
+    expect(None.none?).to be_truthy
+    expect(Some(1).none?).to be_falsey
+  end
+
+  it "value" do
+    expect(Some(1).value).to eq 1
+    expect{ None.value }.to raise_error NoMethodError
+  end
+
+  it "value_or" do
+    expect(Some(1).value_or(2)).to eq 1
+    expect(None.value_or(0)).to eq 0
+  end
+
+  it "+" do
+    expect(Some([1]) + None).to eq Some([1])
+    expect(Some(1) + None + None).to eq Some(1)
+    expect(Some(1) + Some(1)).to eq Some(2)
+    expect(None + Some(1)).to eq Some(1)
+    expect(None + None + Some(1)).to eq Some(1)
+    expect(None + None + Some(1) + None).to eq Some(1)
+    expect(None + Some({foo: 1})).to eq Some({:foo=>1})
+    expect(Some([1]) + Some([1])).to eq Some([1, 1])
+    expect { Some([1]) + Some(1)}.to raise_error TypeError
+  end
+
+  it "inspect" do
+    expect(Some(1).inspect).to eq "Some(1)"
+    expect(described_class::None.new.inspect).to eq "None"
+  end
+
+  it "to_s" do
+    expect(Some(1).to_s).to eq "1"
+    expect(described_class::None.new.to_s).to eq ""
+  end
+
+  it "match" do
     expect(
       Some(0).match {
-        some(1) { |n| 99 }
-        some(0) { |n| n + 1 }
-        none(1) {}
+        Some(s, where { s == 1 } ) { |n| 99 }
+        Some(s, where { s == 0 }) { |n| s + 1 }
+        None() {}
       }
     ).to eq 1
-  }
 
-  specify {
     expect(
-      Some(nil).match {
-        none { 0 }
-        some { 1 }
+      Some(1).match {
+        None() { 0 }
+        Some(s) { 1 }
       }
     ).to eq 1
-  }
 
-  specify {
     expect(
       Some(1).match {
-        none { 0 }
-        some(Fixnum) { 1 }
+        None() { 0 }
+        Some(s, where { s.is_a? Fixnum }) { 1 }
       }
     ).to eq 1
-  }
 
-  specify {
     expect(
       None.match {
-        none { 0 }
-        some { 1 }
+        None() { 0 }
+        Some() { 1 }
       }
     ).to eq 0
-  }
+  end
 
-end
+  it "nil?" do
+    expect(described_class.some?(nil)).to eq None
+    expect(described_class.some?(1)).to be_some
+    expect(described_class.some?(1)).to eq Some(1)
+  end
 
-describe Deterministic::Option::Some do
-  include Deterministic
+  it "any?" do
+    expect(described_class.any?(nil)).to be_none
+    expect(described_class.any?(None)).to be_none
+    expect(described_class.any?("")).to  be_none
+    expect(described_class.any?([])).to  be_none
+    expect(described_class.any?({})).to  be_none
+    expect(described_class.any?([1])).to eq Some([1])
+    expect(described_class.any?({foo: 1})).to eq Some({foo: 1})
+  end
 
-  it_behaves_like 'a Monad' do
-    let(:monad) { described_class }
+  it "try!" do
+    expect(described_class.try! { raise "error" }).to be_none
   end
 end
 
-describe Deterministic::Option::None do
-  include Deterministic
+require_relative 'monad_axioms'
 
-  it_behaves_like 'a Monad' do
+describe Deterministic::Option::Some do
+   it_behaves_like 'a Monad' do
     let(:monad) { described_class }
   end
 end
+
+# describe Deterministic::Option::None do
+#    it_behaves_like 'a Monad' do
+
+#     let(:monad) { described_class }
+#   end
+# end