deterministic 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 718affa7e1715d28293a98600c6112c800d32d3a
-  data.tar.gz: 600f1c5da38df13e625da735485af9e373a240e4
+  metadata.gz: 24278b8af8e996a30226c448b0677f8669e14606
+  data.tar.gz: 6a67ad79ac2e6ff81e0530b547c658f0cfb4633a
 SHA512:
-  metadata.gz: fe73aa1b7315083c0ccfc507b240ef981293f2d8e3ceb89dc02ad3386ca5e14286b7fd944f911feb1e5d7ba9874fb364071e293062b77ef1172e9e43af334172
-  data.tar.gz: 6070733d16a169a9e2b4b7685b90805a5758fb5146ffc9803a26ce58793a24ce93f4711332ae320aac3a81bec51cd8b530ddcc3be93dbfd068bd29f10d13f33c
+  metadata.gz: 0fd77c14af51a1814426d1c33bffccda8b97a58c5266638503dca676e1cbd78ac8a159becabfb3e4fe262016b5a2d0bf1663111f76d0fcbe92e7d105fa296f52
+  data.tar.gz: 6181518d77416ec8cf02712cd738f56b842deaf212a4ac368b8babcc141c01bf718fb7b9b10f2d11d6109cf36a35db0b3306fce8629cdafca940d239d9a2c675

data/README.md

@@ -1,6 +1,6 @@
 # Deterministic
 
-This is a spiritual successor of the [Monadic gem](http://github.com/pzol/monadic). 
+This is a spiritual successor of the [Monadic gem](http://github.com/pzol/monadic). The goal of the rewrite is to get away from a bit to forceful aproach I took in Monadic, especially when it comes to coercing monads, but also a more practical but at the same time more strict adherence to monad laws.
 
 This gem is still __WORK IN PROGRESS__.
 
@@ -60,6 +60,12 @@ However, the real fun starts if you use it with your own context. You can use th
 
 ### Pattern matching
 Now that you have some result, you want to control flow by providing patterns.
+`#match` can match by
+
+ * success, failure, either or any
+ * values
+ * lambdas
+ * classes
 
 ```ruby
 Success(1).match do
@@ -70,9 +76,9 @@ end # => "either 1"
 ```
 Note1: the inner value has been unwrapped! 
 
-Note2: only the __last__ matching pattern block will be executed, so order __can__ be important.
+Note2: only the __first__ matching pattern block will be executed, so order __can__ be important.
 
-The result returned will be the result of the __last__ `#try` or `#let`. As a side note, `#try` is a monad, `#let` is a functor.
+The result returned will be the result of the __first__ `#try` or `#let`. As a side note, `#try` is a monad, `#let` is a functor.
 
 Values for patterns are good, too:
 
@@ -90,6 +96,14 @@ Success(1).match do
 end # => "Success 1"
 ```
 
+Also you can match the result class
+
+```ruby
+Success([1, 2, 3]).match do
+  success(Array) { |v| v.first }
+end # => 1
+```
+
 Combining `#attempt_all` and `#match` is the ultimate sophistication:
 
 ```ruby

data/lib/deterministic.rb

@@ -1,5 +1,7 @@
 require "deterministic/version"
 
+warn "WARN: Deterministic is meant to run on Ruby 2+" if RUBY_VERSION.to_f < 2
+
 module Deterministic; end
 
 require 'deterministic/monad'

data/lib/deterministic/either.rb

@@ -1,12 +1,4 @@
 module Deterministic
-  def Success(value)
-    Success.new(value)
-  end
-
-  def Failure(value)
-    Failure.new(value)
-  end
-
   class Either
     include Monad
     include Deterministic::PatternMatching
@@ -23,5 +15,19 @@ module Deterministic
       return self if failure?
       return other if other.is_a? Either
     end
+
+    class << self
+      protected :new
+    end
+  end
+
+module_function
+
+  def Success(value)
+    Success.new(value)
+  end
+
+  def Failure(value)
+    Failure.new(value)
   end
 end

data/lib/deterministic/either/attempt_all.rb

@@ -19,6 +19,7 @@ class Deterministic::Either
       end
     end
 
+    # This is a functor
     def try(&block)
       try_p = ->(acc) {
         begin
@@ -32,10 +33,11 @@ class Deterministic::Either
       @tries << try_p
     end
 
+    # Basicly a monad
     def let(sym=nil, &block)
       @tries << ->(acc) { 
-        @context.instance_exec(acc, &block).tap do |value|
-          raise EitherExpectedError unless value.is_a? Either
+        @context.instance_exec(acc.value, &block).tap do |value|
+          raise EitherExpectedError, "Expected the result to be either Success or Failure" unless value.is_a? Either
         end
       }
     end

data/lib/deterministic/either/failure.rb

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

data/lib/deterministic/either/match.rb

@@ -1,23 +1,24 @@
 module Deterministic::PatternMatching
 
-  def match(proc=nil, &block)
-    match = Match.new(self)
-    match.instance_eval &(proc || block)
+  def match(context=self, &block)
+    match = Match.new(self, context)
+    match.instance_eval &block
     match.result
   end
 
   class NoMatchError < StandardError; end
 
   class Match
-    def initialize(container)
+    def initialize(container, context)
       @container  = container
+      @context    = context
       @collection = []
     end
 
     def result
-      matcher = @collection.select { |m| m.matches?(@container.value) }.last
-      raise NoMatchError if matcher.nil?
-      matcher.result(@container.value)
+      matcher = @collection.detect { |m| m.matches?(@container.value) }
+      raise NoMatchError, "No could be made for #{@container}" if matcher.nil?
+      @context.instance_exec(@container.value, &matcher.block)
     end
 
     # TODO: Either specific DSL, will need to move it to Either, later on
@@ -38,17 +39,14 @@ module Deterministic::PatternMatching
       def matches?(value)
         condition.call(value)
       end
-
-      def result(value)
-        block.call(value)
-      end
     end
 
     def push(type, condition, result_block)
       condition_pred = case
-      when condition.nil?;        ->(v) { true }
-      when condition.is_a?(Proc); condition
-      else                        ->(v) { condition == @container.value }
+      when condition.nil?;          ->(v) { true }
+      when condition.is_a?(Proc);   condition
+      when condition.is_a?(Class);  ->(v) { condition === @container.value }
+      else                          ->(v) { condition == @container.value }
       end
 
       matcher_pred = compose_predicates(type_pred[type], condition_pred)

data/lib/deterministic/either/success.rb

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

data/lib/deterministic/monad.rb

@@ -15,26 +15,29 @@ module Deterministic
 
     # The functor: takes a function (a -> b) and applies it to the inner value of the monad (Ma),
     # boxes it back to the same monad (Mb)
-    # fmap :: (a -> b) -> Ma -> Mb
+    # fmap :: (a -> b) -> M a -> M b
     def map(proc=nil, &block)
       result = (proc || block).call(value)
       self.class.new(result)
     end
 
-    # The monad: takes a function which returns a monad, applies
-    # bind :: Ma -> (a -> Mb) -> Mb
+    # The monad: takes a function which returns a monad (of the same type), applies the function
+    # bind :: M a  -> (a -> Mb) -> 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)
-      result = (proc || block).call(value)
-      raise NotMonadError unless result.is_a? Monad
-      self.class.new(result)
+      (proc || block).call(value, self.class).tap do |result|
+        raise NotMonadError unless result.is_a? self.class
+      end
     end
+    alias :'>>=' :bind
 
     # Get the underlying value, return in Haskell
-    # return :: m a -> a
+    # return :: M a -> a
     def value
       @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
       @value == other.instance_variable_get(:@value)

data/lib/deterministic/version.rb

@@ -1,3 +1,3 @@
 module Deterministic
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/spec/examples/bookings_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'deterministic'
+
+include Deterministic
+
+module Examples
+  module Bookings
+
+    module Adapters
+      class BookingsRepo
+        def find(params)
+        end
+      end
+    end
+
+    class FakeWebUi
+      def method_missing(m, *args)
+        { m => args }
+      end
+    end
+
+    class Dependencies
+      include Adapters
+      def bookings_repo
+        BookingsRepo.new
+      end
+    end
+
+    class ShowBookings
+      def initialize(world=FakeWebUi.new, deps=Dependencies.new)
+        @world         = world
+        @world.booking_list([])
+      end
+
+      def call(dirty_params)
+        result = Either.attempt_all(self) do
+          try {          parse_params(dirty_params) }
+          let { |params| read_bookings(params)           }
+        end.match(world) do
+          success(Array)         { |bookings| booking_list(bookings) }
+          success                { |booking|  booking(booking)       }
+          failure(:no_bookings)  { empty_booking_list                }
+          failure(StandardError) { |ex| raise ex }
+          any                    { |result| raise "Something went terribly wrong `#{result.class}`" }
+        end
+      end
+
+    # private
+      attr_reader   :bookings_repo, :world
+
+      def parse_params(dirty_params)
+        dirty_params
+      end
+
+      def read_bookings(params)
+        bookings = [params]
+        case bookings
+          when nil; Failure(:no_bookings)
+          when bookings.count == 1; 
+          else Success(bookings)
+        end
+      end
+    end
+  end
+end
+
+describe Examples::Bookings::ShowBookings do
+  subject { described_class.new }
+  it "works" do
+    expect(
+      subject.call({status: 'confirmed'})
+    ).to eq({:booking_list=>[[{:status=>"confirmed"}]]})
+  end
+end

data/spec/examples/validate_address_spec.rb

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

data/spec/lib/deterministic/attempt_all_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'deterministic'
 
 include Deterministic
 
@@ -64,6 +63,15 @@ describe Deterministic::Either::AttemptAll do
     }.to raise_error
   end
 
+  it "#let passes params unboxed" do
+    expect(
+      Either.attempt_all do
+        try { 1 }
+        let { |v| Success(v + 1) }
+      end
+    ).to eq Success(2)
+  end
+
   it "works with an OpenStruct" do
     context = OpenStruct.new
     attempt = Either.attempt_all(context) do
@@ -75,23 +83,23 @@ describe Deterministic::Either::AttemptAll do
     expect(context.alpha).to eq 2
   end
 
-  it "can operate in the context of a host" do
-    class Host
+  it "can operate in the context of a context" do
+    class Context
       attr_accessor :a
       def initialize
         @a = 1
       end
     end
 
-    host = Host.new
+    context = Context.new
 
     expect(
-      Either.attempt_all(host) do
+      Either.attempt_all(context) do
         try { self.a += 1 }
         try { self.a + 1 }
       end
     ).to eq Success(3)
 
-    expect(host.a).to eq 2
+    expect(context.a).to eq 2
   end
 end

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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'deterministic'
 
 include Deterministic
 
@@ -34,6 +33,20 @@ describe Deterministic::Either::Match do
     ).to eq "matched 2"
   end
 
+  it "can match with classes" do
+    expect(
+      Success([1, 2, 3]).match do
+        success(Array) { |v| v.first }
+      end
+    ).to eq 1
+
+    expect(
+      Success(1).match do
+        success(Fixnum) { |v| v }
+      end
+    ).to eq 1
+  end
+
   it "catch-all" do
     expect(
       Success(1).match do
@@ -55,6 +68,7 @@ describe Deterministic::Either::Match do
   it "can match with lambdas" do
     expect(
       Success(1).match do
+        failure                  { "not me" }
         success ->(v) { v == 1 } { |v| "matched #{v}" }
       end
     ).to eq "matched 1"

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

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require_relative '../monad_axioms'
-require 'deterministic'
 
 include Deterministic
 
@@ -17,7 +16,6 @@ describe Deterministic::Success do
   specify { expect(subject).to be_success }
   specify { expect(subject).not_to be_failure }
 
-  # public constructor #Success[]
   specify { expect(subject).to be_an_instance_of described_class }
   specify { expect(subject).to eq(described_class.new(1)) }
   specify { expect(subject << Success(2)).to eq(Success(2)) }
@@ -30,6 +28,4 @@ describe Deterministic::Success do
       subject.bind { |v| true ? Success(v + 1) : Failure(v + 2)}
     ).to eq Success(2)
   end
-
-  specify { expect { Success("a").bind(&:upcase) }.to raise_error(Deterministic::Monad::NotMonadError) }
 end

data/spec/lib/deterministic/either_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Deterministic::Either do
+  it "can't call Either#new directly" do
+   expect { described_class.new(1)}
+    .to raise_error(NoMethodError, "protected method `new' called for Deterministic::Either:Class")
+  end
+end

data/spec/lib/deterministic/monad_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require_relative 'monad_axioms'
-require 'deterministic'
 
 
 describe Deterministic::Monad do
@@ -17,7 +16,28 @@ describe Deterministic::Monad do
   specify { expect(Identity.new([1, 2]).map(&:to_s)).to eq Identity.new("[1, 2]") }
   specify { expect(Identity.new(1).map {|v| v + 2}).to eq Identity.new(3) }
   specify { expect(Identity.new('foo').map(&:upcase)).to eq Identity.new('FOO')}
-  specify { expect { Identity.new(1).bind {} }.to raise_error(Deterministic::Monad::NotMonadError) }
+
+  context '#bind' 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) }
+
+    it "passes the monad class, this is ruby-fu?!" do
+     Identity.new(1)
+      .bind do |_, monad|
+        p self.class
+        expect(monad).to eq Identity
+        monad.new(_)
+      end
+    end
+
+    specify { expect(
+      Identity.new(1).bind { |value, monad| 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

data/spec/spec_helper.rb

@@ -21,3 +21,4 @@ RSpec.configure do |config|
   end
   config.order = 'random'
 end
+require 'deterministic'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deterministic
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Piotr Zolnierek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-28 00:00:00.000000000 Z
+date: 2014-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -132,9 +132,12 @@ files:
 - lib/deterministic/either/success.rb
 - lib/deterministic/monad.rb
 - lib/deterministic/version.rb
+- spec/examples/bookings_spec.rb
+- spec/examples/validate_address_spec.rb
 - spec/lib/deterministic/attempt_all_spec.rb
 - spec/lib/deterministic/either/match_spec.rb
 - spec/lib/deterministic/either/success_spec.rb
+- spec/lib/deterministic/either_spec.rb
 - spec/lib/deterministic/monad_axioms.rb
 - spec/lib/deterministic/monad_spec.rb
 - spec/spec_helper.rb
@@ -158,14 +161,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: see above
 test_files:
+- spec/examples/bookings_spec.rb
+- spec/examples/validate_address_spec.rb
 - spec/lib/deterministic/attempt_all_spec.rb
 - spec/lib/deterministic/either/match_spec.rb
 - spec/lib/deterministic/either/success_spec.rb
+- spec/lib/deterministic/either_spec.rb
 - spec/lib/deterministic/monad_axioms.rb
 - spec/lib/deterministic/monad_spec.rb
 - spec/spec_helper.rb