deterministic 0.8.1 → 0.10.0

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

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

data/spec/lib/deterministic/maybe_spec.rb

@@ -11,6 +11,8 @@ describe 'maybe' do
     expect(Maybe({a: 1})[:a]).to eq 1
     expect(Maybe("a").upcase).to eq "A"
     expect(Maybe("a")).not_to be_none
+
+    # expect(Maybe[[]]).to eq be_none
   end
 
 end

data/spec/lib/deterministic/monad_spec.rb

@@ -13,9 +13,9 @@ describe Deterministic::Monad do
 
   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, 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')}
 
   context '#bind' do
     it "raises an error if the passed function does not return a monad of the same class" do 

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

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+include Deterministic
+
+describe Deterministic::Result do
+  context ">> (map)" do
+    specify { expect(Success(0).map { |n| Success(n + 1) }).to eq Success(1) }
+    specify { expect(Failure(0).map { |n| Success(n + 1) }).to eq Failure(0) }
+
+    it "Failure stops execution" do
+      class ChainUnderTest
+        alias :m :method
+
+        def call
+          init >>
+            m(:validate) >> 
+            m(:send) >> 
+            m(:parse)
+        end
+
+        def init
+          Success({step: 1})
+        end
+
+        def validate(i)
+          i[:step] = i[:step] + 1
+          Success(i)
+        end
+
+        def send(i)
+          i[:step] = i[:step] + 1
+          Failure("Error @ #{i.fetch(:step)}")
+        end
+
+        def parse(i)
+          i[:step] = i[:step] + 1
+          Success(i)
+        end
+      end
+
+      test = ChainUnderTest.new
+
+      expect(test.call).to eq Failure("Error @ 3")
+    end
+
+    it "expects an Result" do
+      def returns_non_result(i)
+        2
+      end
+
+      expect { Success(1) >> method(:returns_non_result) }.to raise_error(Deterministic::Monad::NotMonadError)
+    end
+
+    it "works with a block" do
+      expect(
+        Success(1).map { |i| Success(i + 1) }
+      ).to eq Success(2)
+    end
+
+    it "works with a lambda" do
+      expect(
+        Success(1) >> ->(i) { Success(i + 1) }
+      ).to eq Success(2)
+    end
+
+    it "does not catch exceptions" do
+      expect {
+        Success(1) >> ->(i) { raise "error" }
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  context "using self as the context for success" do
+    class SelfContextUnderTest
+      def call
+        @step = 0
+        Success(self).
+          map(&:validate).
+          map(&:build).
+          map(&:send)
+      end
+
+      def validate
+        @step = 1
+        Success(self)
+      end
+
+      def build
+        @step = 2
+        Success(self)
+      end
+
+      def send
+        @step = 3
+        Success(self)
+      end
+
+      def to_s
+        "Step #{@step}"
+      end
+
+      # # def self.procify(*meths)
+      # #   meths.each do |m|
+      # #     new_m = "__#{m}__procified".to_sym
+      # #     alias new_m m
+      # #     define_method new_m do |ctx|
+      # #       method(m)
+      # #     end
+      # #   end
+      # # end
+
+      # procify :send
+    end
+
+    it "works" do
+      test = SelfContextUnderTest.new.call
+      expect(test).to be_a Success
+      expect(test.inspect).to eq "Success(Step 3)"
+    end
+  end
+
+  context "** (pipe)" do
+    it "ignores the output of pipe" do
+      acc = "ctx: "
+      log = ->(ctx) { acc += ctx.inspect }
+
+      actual = Success(1).pipe(log).map { Success(2) }
+      expect(actual).to eq Success(2)
+      expect(acc).to eq "ctx: Success(1)"
+    end
+
+    it "works with **" do
+      log = ->(n) { n.value + 1 }
+      foo = ->(n) { Success(n + 1) }
+
+      actual = Success(1) ** log >> foo 
+    end
+  end
+
+  context ">= (try)" do
+    it "try (>=) catches errors and wraps them as Failure" do
+      def error(ctx)
+        raise "error #{ctx}"
+      end
+
+      actual = Success(1) >= method(:error)
+      expect(actual.inspect).to eq "Failure(error 1)"
+    end
+  end
+end

data/spec/lib/deterministic/{either → result}/failure_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 require_relative '../monad_axioms'
-require_relative 'either_shared'
+require_relative 'result_shared'
 
 include Deterministic
 
@@ -18,18 +18,21 @@ describe Deterministic::Failure do
 
   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(Failure(1)) }
-  specify { expect(subject << Failure(2)).to eq(Failure(1)) }
-  specify { expect(subject.map { |v| v + 1} ).to eq Failure(2) }
+  specify { expect(subject.fmap { |v| v + 1} ).to eq Failure(2) }
+  specify { expect(subject.map { |v| Success(v + 1)} ).to eq Failure(1) }
+  specify { expect(subject.map_err { |v| Success(v + 1)} ).to eq Success(2) }
+  specify { expect(subject.pipe { |v| raise RuntimeError unless v == Failure(1) } ).to eq Failure(1) }
 
   specify { expect(subject.or(Success(2))).to eq Success(2)}
+  specify { expect(subject.or(Failure(2))).to eq Failure(2)}
   specify { expect(subject.or_else { Success(2) }).to eq Success(2)}
+  specify { expect(subject.or_else { Failure(2) }).to eq Failure(2)}
 
   specify { expect(subject.and(Success(2))).to eq Failure(1)}
   specify { expect(subject.and_then { Success(2) }).to eq Failure(1)}
 
-  it_behaves_like 'Either' do
-    let(:either) { described_class }
+  it_behaves_like 'Result' do
+    let(:result) { described_class }
   end
 end
 

data/spec/lib/deterministic/{either → result}/match_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 include Deterministic
 
-describe Deterministic::Either::Match do
+describe Deterministic::Result::Match do
   it "can match Success" do
     expect(
       Success(1).match do
@@ -55,14 +55,14 @@ describe Deterministic::Either::Match do
     ).to eq "catch-all"
   end
 
-  it "can match either" do
+  it "can match result" do
     expect(
       Failure(2).match do
         success    { |v| "not matched s"  }
-        either(2)  { |v| "either #{v}"    }
+        result(2)  { |v| "result #{v}"    }
         failure(3) { |v| "not matched f3" }
       end
-    ).to eq "either 2"
+    ).to eq "result 2"
   end
 
   it "can match with lambdas" do
@@ -93,7 +93,7 @@ describe Deterministic::Either::Match do
     ).to eq "it works"
   end
 
-  it "allows for Either values to play with pattern matching comparisons" do
+  it "allows for Result values to play with pattern matching comparisons" do
     class MyErrorHash < Hash
       def ==(error_type_symbol)
         self[:type] == error_type_symbol

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

@@ -0,0 +1,23 @@
+shared_examples 'Result' do
+  let(:result_name) { described_class.name.split("::")[-1]}
+  specify { expect(subject.value).to eq 1 }
+  specify { expect(result.new(subject)).to eq result.new(1) }
+
+  it "#fmap" do
+    expect(result.new(1).fmap { |e| e + 1 }).to eq result.new(2)
+  end
+
+  it "#bind" do
+    expect(result.new(1).bind { |v| result.new(v + 1)}).to eq result.new(2)
+  end
+
+  it "#to_s" do
+    expect(result.new(1).to_s).to eq "1"
+    expect(result.new({a: 1}).to_s).to eq "{:a=>1}"
+  end
+
+  it "#inspect" do
+    expect(result.new(1).inspect).to eq "#{result_name}(1)"
+    expect(result.new(:a=>1).inspect).to eq "#{result_name}({:a=>1})"
+  end
+end

data/spec/lib/deterministic/{either → result}/success_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 require_relative '../monad_axioms'
-require_relative 'either_shared'
+require_relative 'result_shared'
 
 include Deterministic
 
@@ -18,17 +18,21 @@ describe Deterministic::Success do
 
   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(subject.map { |v| v + 1} ).to eq Success(2) }
+  specify { expect(subject.fmap { |v| v + 1} ).to eq Success(2) }
+  specify { expect(subject.map { |v| Failure(v + 1) } ).to eq Failure(2) }
+  specify { expect(subject.map_err { |v| Failure(v + 1) } ).to eq Success(1) }
+
+  specify { expect(subject.pipe{ |r| raise RuntimeError unless r == Success(1) } ).to eq Success(1) }
 
   specify { expect(subject.or(Success(2))).to eq Success(1)}
   specify { expect(subject.or_else { Success(2) }).to eq Success(1)}
 
   specify { expect(subject.and(Success(2))).to eq Success(2)}
+  specify { expect(subject.and(Failure(2))).to eq Failure(2)}
   specify { expect(subject.and_then { Success(2) }).to eq Success(2)}
+  specify { expect(subject.and_then { Failure(2) }).to eq Failure(2)}
 
-  it_behaves_like 'Either' do
-    let(:either) { described_class }
+  it_behaves_like 'Result' do
+    let(:result) { described_class }
   end
 end

data/spec/lib/deterministic/{either_spec.rb → result_spec.rb}

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deterministic
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Piotr Zolnierek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-15 00:00:00.000000000 Z
+date: 2014-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -119,39 +119,37 @@ files:
 - .rspec
 - Gemfile
 - Guardfile
+- HISTORY.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - deterministic.gemspec
-- either.rb
 - lib/deterministic.rb
-- lib/deterministic/core_ext/either.rb
-- lib/deterministic/core_ext/object/either.rb
-- lib/deterministic/either.rb
-- lib/deterministic/either/attempt_all.rb
-- lib/deterministic/either/chain.rb
-- lib/deterministic/either/failure.rb
-- lib/deterministic/either/match.rb
-- lib/deterministic/either/success.rb
+- lib/deterministic/core_ext/object/result.rb
+- lib/deterministic/core_ext/result.rb
 - lib/deterministic/maybe.rb
 - lib/deterministic/monad.rb
 - lib/deterministic/none.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/validate_address_spec.rb
-- spec/lib/deterministic/attempt_all_spec.rb
-- spec/lib/deterministic/core_ext/either_spec.rb
 - spec/lib/deterministic/core_ext/object/either_spec.rb
-- spec/lib/deterministic/either/chain_spec.rb
-- spec/lib/deterministic/either/either_shared.rb
-- spec/lib/deterministic/either/failure_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/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/result/chain_spec.rb
+- spec/lib/deterministic/result/failure_spec.rb
+- spec/lib/deterministic/result/match_spec.rb
+- spec/lib/deterministic/result/result_shared.rb
+- spec/lib/deterministic/result/success_spec.rb
+- spec/lib/deterministic/result_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/pzol/deterministic
 licenses:
@@ -180,17 +178,16 @@ 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/core_ext/either_spec.rb
 - spec/lib/deterministic/core_ext/object/either_spec.rb
-- spec/lib/deterministic/either/chain_spec.rb
-- spec/lib/deterministic/either/either_shared.rb
-- spec/lib/deterministic/either/failure_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/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/result/chain_spec.rb
+- spec/lib/deterministic/result/failure_spec.rb
+- spec/lib/deterministic/result/match_spec.rb
+- spec/lib/deterministic/result/result_shared.rb
+- spec/lib/deterministic/result/success_spec.rb
+- spec/lib/deterministic/result_spec.rb
 - spec/spec_helper.rb

data/either.rb

@@ -1,97 +0,0 @@
-class Either
-	def chain(&callee)
-		return self if @value.failure?
-		value = callee.call
-		raise "value must be either Success or Failure" unless Either::Abstract === value
-		@value = value
-		return self
-	end
-
-	def self.success(value)
-		Success.new(value)
-	end
-
-	def self.failure(value)
-		Failure.new(value)
-	end
-
-	class Abstract
-		def initialize(value)
-			@value = value
-		end
-	end
-
-	class Success < Abstract
-		def <<(value)
-			@value = value
-		end
-
-		def or(*args)
-			self
-		end
-
-		def success?
-			true
-		end
-
-		def failure?
-			false
-		end
-	end
-
-	class Failure < Abstract
-		def <<(value)
-			@value = value
-		end
-
-		def or(value)
-			value
-		end
-
-		def success?
-			false
-		end
-
-		def failure?
-			true
-		end
-	end
-end
-
-# a container for storing intermediate state
-class Builder
-	def initialize(deps)
-		@settings_adapter = deps.fetch(:settings)
-	end
-
-	def build
-		Either.new do
-			on_failure do |result|
-				p result
-			end
-
-			chain { @settings = @settings_adapter.call(a, b) }
-		end
-	end
-
-end
-
-module SettingsAdapter
-	def self.call(contract, facility)
-		begin
-			client = ResfinitySettingsClient::Client.new
-			auth = self.auth
-			Either.success(client.settings(auth))
-		rescue => ex
-			Either.failure(["Could not get settings: #{ex.message}", ex])
-		end
-	end
-	
-	def self.auth
-		{ 
-			# config to external
-			api_user: 	ENV['SETTINGS_USER'],
-			api_token:	ENV['SETTINGS_TOKEN']
-		}
-	end
-end

data/lib/deterministic/core_ext/object/either.rb

@@ -1,6 +0,0 @@
-require "deterministic/core_ext/either"
-
-include Deterministic
-class Object
-  include Deterministic::CoreExt::Either
-end

data/lib/deterministic/either/attempt_all.rb

@@ -1,50 +0,0 @@
-require 'ostruct'
-
-class Deterministic::Either
-  def self.attempt_all(context=OpenStruct.new, &block)
-    AttemptAll.new(context, &block).call
-  end
-
-  class AttemptAll
-    class EitherExpectedError < StandardError; end
-    def initialize(context, &block)
-      @context = context || self
-      @tries = []
-      instance_eval(&block)
-    end
-
-    def call(initial=nil)
-      result = @tries.inject(Deterministic::Success(initial)) do |acc, try|
-        acc.success? ? acc << try.call(acc) : acc
-      end
-    end
-
-    # This is a functor
-    def try(&block)
-      try_p = ->(acc) {
-        begin
-          value = @context.instance_exec(acc.value, &block)
-          case value
-          when Deterministic::Success, Deterministic::Failure
-            value
-          else
-            Deterministic::Success(value)
-          end
-        rescue => ex
-          Deterministic::Failure(ex)
-        end
-      }
-
-      @tries << try_p
-    end
-
-    # Basicly a monad
-    def let(sym=nil, &block)
-      @tries << ->(acc) {
-        @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
-  end
-end

data/lib/deterministic/either/chain.rb

@@ -1,22 +0,0 @@
-module Deterministic
-  class Either
-    module Chain
-      def chain(proc=nil, &block)
-        return self if failure?
-        bind { (proc || block).call(@value) }
-      end
-
-      alias :>> :chain
-
-      def try(proc=nil, &block)
-        return self if failure?
-        bind { (proc || block).call(@value) }
-      rescue => err
-        Failure(err)
-      end
-
-      alias :>= :try
-    end
-  end
-end
-

data/lib/deterministic/either/failure.rb

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