deterministic 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 925b4c6bf8684358c92969bd99bfaae834ecc96d
-  data.tar.gz: b9e69ef69dbd5fe6e050265d41a39375471b4acc
+  metadata.gz: 718affa7e1715d28293a98600c6112c800d32d3a
+  data.tar.gz: 600f1c5da38df13e625da735485af9e373a240e4
 SHA512:
-  metadata.gz: e1d622aec6a69088627ab300883863815e85b7f67b4080072271644aaba31591942f2d23249751047f5d25e850a933414804a59641bb216a3e572a817aebde75
-  data.tar.gz: 9637ca25bc179cfc53464b618e3c8e09332bd3e52085a1c750aaf2715feea65c5ccd701be4cf5388f334f5835007b532ff5f87d8b8edd142592e59bf3656f9a0
+  metadata.gz: fe73aa1b7315083c0ccfc507b240ef981293f2d8e3ceb89dc02ad3386ca5e14286b7fd944f911feb1e5d7ba9874fb364071e293062b77ef1172e9e43af334172
+  data.tar.gz: 6070733d16a169a9e2b4b7685b90805a5758fb5146ffc9803a26ce58793a24ce93f4711332ae320aac3a81bec51cd8b530ddcc3be93dbfd068bd29f10d13f33c

data/README.md

@@ -1,20 +1,8 @@
 # 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). 
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'deterministic'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install deterministic
+This gem is still __WORK IN PROGRESS__.
 
 ## Usage
 
@@ -80,11 +68,76 @@ Success(1).match do
   either  { |v| "either #{v}"}
 end # => "either 1"
 ```
-Note: the inner value has been unwrapped! 
+Note1: the inner value has been unwrapped! 
+
+Note2: only the __last__ 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.
+
+Values for patterns are good, too:
+
+```ruby
+Success(1).match do
+  success(1) { "Success #{v}" }
+end # => "Success 1"
+```
+
+You can and should also use procs for patterns:
+
+```ruby
+Success(1).match do
+  success ->(v) { v == 1} { "Success #{v}" }
+end # => "Success 1"
+```
+
+Combining `#attempt_all` and `#match` is the ultimate sophistication:
 
-Note2: only the last matching pattern block will be executed
+```ruby
+Either.attempt_all do
+  try { 1 }
+  try { |v| v + 1 }
+end.match do
+  success(1) { |v| "We made it to step #{v}" }
+  success(2) { |v| "The correct answer is #{v}"}
+end # => "The correct answer is 2"
+```
 
-The result returned will be the result of the last `#try` or `#let`
+If no match was found a `NoMatchError` is raised, so make sure you always cover all possible outcomes.
+
+```ruby
+Success(1).match do
+  failure(1) { "you'll never get me" }
+end # => NoMatchError
+```
+
+A way to have a catch-all would be using an `any`:
+
+```ruby
+Success(1).match do
+  any { "catch-all" }
+end # => "catch-all"
+```
+
+## Inspirations
+ * My [Monadic gem](http://github.com/pzol/monadic) of course
+ * `#attempt_all` was somewhat inspired by [An error monad in Clojure](http://brehaut.net/blog/2011/error_monads)
+ * [Pithyless' rumblings](https://gist.github.com/pithyless/2216519) 
+ * [either by rsslldnphy](https://github.com/rsslldnphy/either)
+ * [Functors, Applicatives, And Monads In Pictures](http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'deterministic'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install deterministic
 
 ## Contributing
 
@@ -93,8 +146,3 @@ The result returned will be the result of the last `#try` or `#let`
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
-
-## Inspirations
- * My [Monadic gem](http://github.com/pzol/monadic) of course
- * `#attempt_all` was somewhat inspired by [An error monad in Clojure](http://brehaut.net/blog/2011/error_monads)
- * [Pithyless' rumblings](https://gist.github.com/pithyless/2216519) 

data/lib/deterministic/either/attempt_all.rb

@@ -1,5 +1,6 @@
 require 'ostruct'
-module Deterministic::Either
+
+class Deterministic::Either
   def self.attempt_all(context=OpenStruct.new, &block)
     AttemptAll.new(context, &block).call
   end
@@ -14,7 +15,7 @@ module Deterministic::Either
 
     def call(initial=nil)
       result = @tries.inject(Success(initial)) do |acc, try|
-        acc.success? ? acc.bind(try.call(acc)) : acc
+        acc.success? ? acc << try.call(acc) : acc
       end
     end
 

data/lib/deterministic/either/failure.rb

@@ -1,3 +1,3 @@
-module Deterministic::Either
+module Deterministic
   class Failure < Either; end
 end

data/lib/deterministic/either/match.rb

@@ -1,44 +1,67 @@
-module Deterministic::Either
+module Deterministic::PatternMatching
+
   def match(proc=nil, &block)
     match = Match.new(self)
     match.instance_eval &(proc || block)
     match.result
   end
 
+  class NoMatchError < StandardError; end
+
   class Match
-    def initialize(either)
-      @either     = either
+    def initialize(container)
+      @container  = container
       @collection = []
     end
 
-    def success(value=nil, &block)
-      q(:success, value, block)
+    def result
+      matcher = @collection.select { |m| m.matches?(@container.value) }.last
+      raise NoMatchError if matcher.nil?
+      matcher.result(@container.value)
     end
 
-    def failure(value=nil, &block)
-      q(:failure, value, block)
+    # TODO: Either specific DSL, will need to move it to Either, later on
+    %w[Success Failure Either].each do |s|
+      define_method s.downcase.to_sym do |value=nil, &block|
+        klas = Module.const_get(s)
+        push(klas, value, block)
+      end
     end
 
-    def either(value=nil, &block)
-      q(:either, value, block)
+    # catch-all
+    def any(value=nil, &result_block)
+      push(Object, value, result_block)
     end
 
-    def result
-      matcher = @collection.select { |m| m.first.call(@either.value) }.last
-      matcher.last.call(@either.value)
+  private
+    Matcher = Struct.new(:condition, :block) do 
+      def matches?(value)
+        condition.call(value)
+      end
+
+      def result(value)
+        block.call(value)
+      end
     end
 
-  private
-    def q(type, condition, block)
-      if condition.nil?
-        condition_p = ->(v) { true }
-      elsif condition.is_a?(Proc)
-        condition_p = condition
-      else
-        condition_p = ->(v) { condition == @either.value }
+    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 }
       end
 
-      @collection << [condition_p, block] if @either.is? type
+      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/either/success.rb

@@ -1,3 +1,3 @@
-module Deterministic::Either
+module Deterministic
   class Success < Either; end
 end

data/lib/deterministic/either.rb

@@ -1,24 +1,15 @@
-module Deterministic::Either
+module Deterministic
   def Success(value)
-    Success.unit(value)
+    Success.new(value)
   end
 
   def Failure(value)
-    Failure.unit(value)
+    Failure.new(value)
   end
 
   class Either
-    def self.unit(value)
-      return value if value.is_a? Either
-      # return Failure.new(value)       if value.nil? || (value.respond_to?(:empty?) && value.empty?) || !value
-      # return Success.new(value)
-      return new(value)
-    end
-
-    def is?(s)
-      const_name = s.slice(0,1).capitalize + s.slice(1..-1)
-      is_a? Module.const_get(const_name)
-    end
+    include Monad
+    include Deterministic::PatternMatching
 
     def success?
       is_a? Success
@@ -28,31 +19,9 @@ module Deterministic::Either
       is_a? Failure
     end
 
-    def bind(other)
+    def <<(other)
       return self if failure?
       return other if other.is_a? Either
-      # return concat(proc) if proc.is_a? Either
-
-      # begin
-      #   Either(call(proc, block))
-      # rescue StandardError => error
-      #   Failure(error)
-      # end
-    end
-
-    # get the underlying value
-    def value
-      @value
-    end
-
-    def ==(other)
-      return false unless other.is_a? self.class
-      @value == other.instance_variable_get(:@value)
-    end
-
-  private
-    def initialize(value) 
-      @value = value
     end
   end
 end

data/lib/deterministic/monad.rb

@@ -0,0 +1,49 @@
+module Deterministic
+  module Monad
+    class NotMonadError < StandardError; end
+
+    def initialize(value) 
+      @value = join(value)
+    end
+
+    # If the passed value is monad already, get the value to avoid nesting
+    # M[M[A]] is equivalent to M[A]
+    def join(value)
+      if value.is_a? self.class then value.value
+      else value end
+    end
+
+    # 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
+    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
+    def bind(proc=nil, &block)
+      result = (proc || block).call(value)
+      raise NotMonadError unless result.is_a? Monad
+      self.class.new(result)
+    end
+
+    # Get the underlying value, return in Haskell
+    # return :: m a -> a
+    def value
+      @value
+    end
+
+    def ==(other)
+      return false unless other.is_a? self.class
+      @value == other.instance_variable_get(:@value)
+    end
+
+    # Return the string representation of the Monad
+    def to_s
+      pretty_class_name = self.class.name.split('::')[-1]
+      "#{pretty_class_name}(#{self.value.inspect})"
+    end
+  end
+end

data/lib/deterministic/version.rb

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

data/lib/deterministic.rb

@@ -2,8 +2,9 @@ require "deterministic/version"
 
 module Deterministic; end
 
-require 'deterministic/either'
+require 'deterministic/monad'
 require 'deterministic/either/match'
+require 'deterministic/either'
 require 'deterministic/either/attempt_all'
 require 'deterministic/either/success'
 require 'deterministic/either/failure'

data/spec/lib/deterministic/attempt_all_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 require 'deterministic'
 
-include Deterministic::Either
 include Deterministic
 
 describe Deterministic::Either::AttemptAll do

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'deterministic'
 
-include Deterministic::Either
+include Deterministic
 
 describe Deterministic::Either::Match do
   it "can match Success" do
@@ -34,6 +34,14 @@ describe Deterministic::Either::Match do
     ).to eq "matched 2"
   end
 
+  it "catch-all" do
+    expect(
+      Success(1).match do
+        any { "catch-all" }
+      end
+    ).to eq "catch-all"
+  end
+
   it "can match either" do
     expect(
       Failure(2).match do
@@ -44,11 +52,19 @@ describe Deterministic::Either::Match do
     ).to eq "either 2"
   end
 
-  it "can mach with lambdas" do
+  it "can match with lambdas" do
     expect(
       Success(1).match do
         success ->(v) { v == 1 } { |v| "matched #{v}" }
       end
     ).to eq "matched 1"
   end
+
+  it "no match" do
+    expect {
+      Success(1).match do
+        failure { "you'll never get me" }
+      end
+    }.to raise_error Deterministic::PatternMatching::NoMatchError
+  end
 end

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

@@ -1,10 +1,16 @@
 require 'spec_helper'
+require_relative '../monad_axioms'
 require 'deterministic'
 
-include Deterministic::Either
+include Deterministic
 
-describe Deterministic::Either::Success do
-  subject { described_class.unit(1) }
+describe Deterministic::Success do
+
+  it_behaves_like 'a Monad' do 
+    let(:monad) { described_class }
+  end
+
+  subject { described_class.new(1) }
 
   specify { expect(subject).to be_an_instance_of described_class }
   specify { expect(subject.value).to eq 1 }
@@ -12,16 +18,18 @@ describe Deterministic::Either::Success do
   specify { expect(subject).not_to be_failure }
 
   # public constructor #Success[]
-  specify { expect(described_class.unit(1)).to be_an_instance_of described_class }
-  specify { expect(subject).to eq(described_class.unit(1))}
+  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)) }
+  specify { expect(subject << Failure(2)).to eq(Failure(2)) }
+  specify { expect(Success(subject)).to eq Success(1) }
+  specify { expect(subject.map { |v| v + 1} ).to eq Success(2) }
 
-  it "handles chaining using &" do
-    expect(Success(1).bind Success(2)).to eq(Success(2))
-    expect(Success(1).bind Failure(2)).to eq(Failure(2))
+  it "#bind" do
+    expect(
+      subject.bind { |v| true ? Success(v + 1) : Failure(v + 2)}
+    ).to eq Success(2)
   end
 
-  specify { expect(Success(Success(1))).to eq Success(1) }
-  specify { expect(Success(1).is? :success).to be true }
-  specify { expect(Success(1).is? :either).to  be true  }
-  specify { expect(Success(1).is? :failure).to be false }
+  specify { expect { Success("a").bind(&:upcase) }.to raise_error(Deterministic::Monad::NotMonadError) }
 end

data/spec/lib/deterministic/monad_axioms.rb

@@ -0,0 +1,48 @@
+shared_examples 'a Monad' do
+  describe 'axioms' do
+    it '1st monadic law: left-identity' do
+      f = ->(value) { monad.new(value + 1) }
+      expect(
+        monad::new(1).bind do |value|
+          f.(value)
+        end
+      ).to eq f.(1)
+    end
+
+    it '2nd monadic law: right-identy - new and bind do not change the value' do
+      expect(
+        monad.new(1).bind do |value|
+          monad.new(value)
+        end
+      ).to eq monad.new(1)
+    end
+
+    it '3rd monadic law: associativity' do
+      f = ->(value) { monad.new(value + 1)   }
+      g = ->(value) { monad.new(value + 100) }
+
+      id1 = monad.new(1).bind do |a|
+        f.(a)
+      end.bind do |b|
+        g.(b)
+      end
+
+      id2 = monad.new(1).bind do |a|
+        f.(a).bind do |b|
+          g.(b)
+        end
+      end
+
+      expect(id1).to eq id2
+    end
+
+    it '#bind must return a monad' do
+      expect(monad.new(1).bind { |v| monad.new(v) }).to eq monad.new(1)
+      expect { monad.new(1).bind {} }.to raise_error(Deterministic::Monad::NotMonadError)
+    end
+
+    it '#new must return a monad' do
+      expect(monad.new(1)).to be_a monad
+    end
+  end
+end

data/spec/lib/deterministic/monad_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require_relative 'monad_axioms'
+require 'deterministic'
+
+
+describe Deterministic::Monad do
+  class Identity 
+    include Deterministic::Monad
+  end
+
+  it_behaves_like 'a Monad' do 
+    let(:monad) { Identity }
+  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, 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) }
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deterministic
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Piotr Zolnierek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-27 00:00:00.000000000 Z
+date: 2013-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -130,10 +130,13 @@ files:
 - lib/deterministic/either/failure.rb
 - lib/deterministic/either/match.rb
 - lib/deterministic/either/success.rb
+- lib/deterministic/monad.rb
 - lib/deterministic/version.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/monad_axioms.rb
+- spec/lib/deterministic/monad_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/pzol/deterministic
 licenses:
@@ -163,4 +166,6 @@ test_files:
 - spec/lib/deterministic/attempt_all_spec.rb
 - spec/lib/deterministic/either/match_spec.rb
 - spec/lib/deterministic/either/success_spec.rb
+- spec/lib/deterministic/monad_axioms.rb
+- spec/lib/deterministic/monad_spec.rb
 - spec/spec_helper.rb