deterministic 0.14.1 → 0.15.0

data/spec/lib/deterministic/protocol_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'deterministic/protocol'
+
+
+module Monoid
+  extend Deterministic::Protocol
+
+  Deterministic::protocol(M) {
+    fn empty() => M
+    fn(append(a => M, b => M) => M) { |a, b|
+      a + b
+    }
+  }
+
+  Int = Deterministic::instance(Monoid, M => Fixnum) {
+    def empty()
+      0
+    end
+
+    def append(a, b)
+      a + b + 1
+    end
+  }
+
+  String = Deterministic::instance(Monoid, M => String) {
+    def empty()
+      ""
+    end
+  }
+end
+
+describe Monoid do
+  it "does something" do
+    expect(described_class.constants).to eq [:Protocol, :Int, :String]
+    int = described_class::Int.new
+    expect(int.empty).to eq 0
+    expect(int.append(1, 2)).to eq 4
+
+    str = described_class::String.new
+    expect(str.empty).to eq ""
+    expect(str.append("a", "b")).to eq "ab"
+  end
+end

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

@@ -2,9 +2,8 @@ require 'spec_helper'
 require_relative '../monad_axioms'
 require_relative 'result_shared'
 
-
 describe Deterministic::Result::Failure do
-  include Deterministic
+  include Deterministic::Prelude::Result
 
   it_behaves_like 'a Monad' do
     let(:monad) { described_class }
@@ -36,11 +35,6 @@ describe Deterministic::Result::Failure do
   it_behaves_like 'Result' do
     let(:result) { described_class }
   end
-end
-
-
-describe "Chaining" do
-  include Deterministic
 
   it "#or" do
     expect(Success(1).or(Failure(2))).to eq Success(1)

data/spec/lib/deterministic/result/{result_map.rb → result_map_spec.rb}

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 
 describe Deterministic::Result do
-  include Deterministic
+  include Deterministic::Prelude::Result
 
   context ">> (map)" do
     specify { expect(Success(0).map { |n| Success(n + 1) }).to eq Success(1) }
@@ -10,14 +10,13 @@ describe Deterministic::Result do
 
     it "Failure stops execution" do
       class ChainUnderTest
-        include Deterministic
-
+        include Deterministic::Prelude::Result
         alias :m :method
 
         def call
           init >>
-            m(:validate) >> 
-            m(:send) >> 
+            m(:validate) >>
+            m(:send) >>
             m(:parse)
         end
 
@@ -75,7 +74,7 @@ describe Deterministic::Result do
 
   context "using self as the context for success" do
     class SelfContextUnderTest
-      include Deterministic
+      include Deterministic::Prelude::Result
 
       def call
         @step = 0
@@ -124,7 +123,7 @@ describe Deterministic::Result do
     end
   end
 
-  context "** (pipe)" do
+  context "<< (pipe)" do
     it "ignores the output of pipe" do
       acc = "ctx: "
       log = ->(ctx) { acc += ctx.inspect }
@@ -134,16 +133,17 @@ describe Deterministic::Result do
       expect(acc).to eq "ctx: Success(1)"
     end
 
-    it "works with **" do
+    it "works with <<" do
       log = ->(n) { n.value + 1 }
       foo = ->(n) { Success(n + 1) }
 
-      actual = Success(1) ** log >> foo 
+      actual = Success(1) << log >> foo
     end
   end
 
   context ">= (try)" do
     it "try (>=) catches errors and wraps them as Failure" do
+      pending "not implemented"
       def error(ctx)
         raise "error #{ctx}"
       end

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

@@ -2,9 +2,8 @@ require 'spec_helper'
 require_relative '../monad_axioms'
 require_relative 'result_shared'
 
-
 describe Deterministic::Result::Success do
-  include Deterministic
+  include Deterministic::Prelude::Result
 
   it_behaves_like 'a Monad' do
     let(:monad) { described_class }

data/spec/lib/deterministic/result_spec.rb

@@ -1,23 +1,52 @@
 require 'spec_helper'
 
 describe Deterministic::Result do
+  include Deterministic::Prelude::Result
+
   it "can't call Result#new directly" do
-    expect { described_class.new(1)}
-    .to raise_error(NoMethodError, "protected method `new' called for Deterministic::Result:Class")
+   expect { described_class.new(1)}
+    .to raise_error(NoMethodError, "private method `new' called for Deterministic::Result:Class")
   end
-end
 
-describe Deterministic::Result do
-  include Deterministic
-  describe "+" do
-    specify { expect(Success(1) + Success(1)).to eq Success(2) }
-    specify { expect(Failure(1) + Failure(1)).to eq Failure(2) }
-    specify { expect { Success([1]) + Success(1)}.to raise_error TypeError}
-    specify { expect { Failure([1]) + Failure(1)}.to raise_error TypeError}
-    specify { expect(Success(1) + Failure(2)).to eq Failure(2) }
-    specify { expect(Failure(1) + Success(2)).to eq Failure(1) }
-    specify { expect(Success(1) + Failure(2) + Failure(3)).to eq Failure(5) }
-    specify { expect(Failure([2]) + Failure([3]) + Success(1)).to eq Failure([2, 3]) }
-    specify { expect(Success([1]) + Success([1])).to eq Success([1, 1]) }
+  it "fmap" do
+    expect(Success(1).fmap { |n| n + 1}).to eq Success(2)
+    expect(Failure(0).fmap { |n| n + 1}).to eq Failure(1)
+  end
+
+  it "map" do
+    expect(Success(1).map { |n| Success(n + 1)}).to eq Success(2)
+    expect(Failure(0).map { |n| Success(n + 1)}).to eq Failure(0)
+  end
+
+  it "+" do
+    expect(Success([1]) + Failure([2])).to eq Failure([2])
+    expect(Success(1) + Success(1)).to eq Success(2)
+    expect(Failure(2) + Success(1)).to eq Failure(2)
+    expect(Failure([2]) + Failure([3]) + Success(1)).to eq Failure([2, 3])
+    expect(Success([1]) + Success([1])).to eq Success([1, 1])
+    expect { Success([1]) + Success(1)}.to raise_error TypeError
   end
+
+  subject { Success(1) }
+  # 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_a described_class }
+  # specify { expect(subject).to eq(described_class.new(1)) }
+  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)}
 end

data/spec/lib/enum_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+require 'deterministic/enum'
+
+describe Deterministic::Enum  do
+  include Deterministic
+
+  it "can't use value" do
+    expect { InvalidEnum = Deterministic::enum {
+      Unary(:value)
+    }}.to raise_error ArgumentError
+  end
+
+  context "Nullary, Unary, Binary" do
+    MyEnym = Deterministic::enum {
+      Nullary()
+      Unary(:a)
+      Binary(:a, :b)
+    }
+
+    it "can't instantiate parent" do
+      expect { MyEnym.new }.to raise_error NoMethodError, "private method `new' called for MyEnym:Class"
+    end
+
+    it "Nullary" do
+      n = MyEnym.Nullary
+
+      expect(n).to be_a MyEnym
+      expect(n).to be_a MyEnym::Nullary
+      expect(n.name).to eq "Nullary"
+      expect { n.value }.to raise_error
+      expect(n.inspect).to eq "Nullary"
+      expect(n.to_s).to eq ""
+      expect(n.fmap { }).to eq n
+    end
+
+    it "Unary" do
+      u = MyEnym::Unary(1)
+
+      expect(u).to be_a MyEnym
+      expect(u).to be_a MyEnym::Unary
+      expect(u.name).to eq "Unary"
+      expect(u.a).to eq 1
+      expect(u.value).to eq 1
+      expect(u.inspect).to eq "Unary(1)"
+      expect(u.to_s).to eq "1"
+    end
+
+    it "Binary" do
+      # hash
+      b = MyEnym::Binary(a: 1, b: 2)
+      expect(b).to be_a MyEnym
+      expect(b).to be_a MyEnym::Binary
+      expect(b.name).to eq "Binary"
+      expect(b.inspect).to eq "Binary(a: 1, b: 2)"
+
+      expect(b.a).to eq 1
+      expect(b.b).to eq 2
+      expect(b.value).to eq({a: 1, b: 2})
+
+      # values only
+      b = MyEnym::Binary(1, 2)
+      expect(b.value).to eq({a: 1, b: 2})
+
+      # other names are ok
+      b = MyEnym::Binary(c: 1, d: 2)
+      expect(b.value).to eq({a: 1, b: 2})
+
+      expect { MyEnym::Binary(1) }.to raise_error ArgumentError
+    end
+
+    it "generated enum" do
+      expect(MyEnym.variants).to eq [:Nullary, :Unary, :Binary]
+      expect(MyEnym.constants.inspect).to eq "[:Nullary, :Unary, :Binary, :Matcher]"
+
+      b = MyEnym::Binary(a: 1, b: 2)
+
+      res =
+        MyEnym.match(b) {
+          Nullary()  { 0 }
+          Unary(a) { [a, b] }
+          Binary(x, y) { [x, y]}
+        }
+
+      expect(res).to eq [1, 2]
+
+      res =
+        b.match {
+          Nullary()  { 0 }
+          Unary(a) { [a, b] }
+          Binary(x, y) { [x, y]}
+        }
+
+      expect(res).to eq [1, 2]
+
+      expect { b.match {
+        Nullary               # Nullary is treated as a constant
+      }
+      }.to raise_error(NameError)
+
+      expect { b.match {
+        Nullary()
+        Unary()
+        Binary()
+      }
+      }.to raise_error ArgumentError, "No block given to `Nullary`"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 require 'simplecov'
 SimpleCov.start
 
+require 'deterministic'
+
 RSpec.configure do |config|
   # Limit the spec run to only specs with the focus metadata. If no specs have
   # the filtering metadata and `run_all_when_everything_filtered = true` then
@@ -23,4 +25,3 @@ RSpec.configure do |config|
 
   config.filter_run_excluding isolate: true
 end
-require 'deterministic'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deterministic
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.15.0
 platform: ruby
 authors:
 - Piotr Zolnierek
@@ -116,7 +116,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".rspec"
 - Gemfile
 - Guardfile
 - HISTORY.md
@@ -128,33 +127,39 @@ files:
 - lib/deterministic/core_ext/object/result.rb
 - lib/deterministic/core_ext/result.rb
 - lib/deterministic/either.rb
+- lib/deterministic/enum.rb
 - lib/deterministic/match.rb
 - lib/deterministic/maybe.rb
 - lib/deterministic/monad.rb
 - lib/deterministic/null.rb
 - lib/deterministic/option.rb
+- lib/deterministic/protocol.rb
 - lib/deterministic/result.rb
 - lib/deterministic/version.rb
-- spec/examples/bookings_spec.rb
+- spec/examples/amount_spec.rb
 - spec/examples/config_spec.rb
 - spec/examples/controller_spec.rb
+- spec/examples/list.rb
+- spec/examples/list_spec.rb
 - spec/examples/logger_spec.rb
 - spec/examples/validate_address_spec.rb
 - spec/lib/deterministic/class_mixin_spec.rb
 - spec/lib/deterministic/core_ext/object/either_spec.rb
 - spec/lib/deterministic/core_ext/result_spec.rb
+- spec/lib/deterministic/currify_spec.rb
 - spec/lib/deterministic/either_spec.rb
 - spec/lib/deterministic/maybe_spec.rb
 - spec/lib/deterministic/monad_axioms.rb
 - spec/lib/deterministic/monad_spec.rb
 - spec/lib/deterministic/null_spec.rb
 - spec/lib/deterministic/option_spec.rb
+- spec/lib/deterministic/protocol_spec.rb
 - spec/lib/deterministic/result/failure_spec.rb
-- spec/lib/deterministic/result/match_spec.rb
-- spec/lib/deterministic/result/result_map.rb
+- spec/lib/deterministic/result/result_map_spec.rb
 - spec/lib/deterministic/result/result_shared.rb
 - spec/lib/deterministic/result/success_spec.rb
 - spec/lib/deterministic/result_spec.rb
+- spec/lib/enum_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/pzol/deterministic
 licenses:
@@ -181,24 +186,28 @@ signing_key:
 specification_version: 4
 summary: see above
 test_files:
-- spec/examples/bookings_spec.rb
+- spec/examples/amount_spec.rb
 - spec/examples/config_spec.rb
 - spec/examples/controller_spec.rb
+- spec/examples/list.rb
+- spec/examples/list_spec.rb
 - spec/examples/logger_spec.rb
 - spec/examples/validate_address_spec.rb
 - spec/lib/deterministic/class_mixin_spec.rb
 - spec/lib/deterministic/core_ext/object/either_spec.rb
 - spec/lib/deterministic/core_ext/result_spec.rb
+- spec/lib/deterministic/currify_spec.rb
 - spec/lib/deterministic/either_spec.rb
 - spec/lib/deterministic/maybe_spec.rb
 - spec/lib/deterministic/monad_axioms.rb
 - spec/lib/deterministic/monad_spec.rb
 - spec/lib/deterministic/null_spec.rb
 - spec/lib/deterministic/option_spec.rb
+- spec/lib/deterministic/protocol_spec.rb
 - spec/lib/deterministic/result/failure_spec.rb
-- spec/lib/deterministic/result/match_spec.rb
-- spec/lib/deterministic/result/result_map.rb
+- spec/lib/deterministic/result/result_map_spec.rb
 - spec/lib/deterministic/result/result_shared.rb
 - spec/lib/deterministic/result/success_spec.rb
 - spec/lib/deterministic/result_spec.rb
+- spec/lib/enum_spec.rb
 - spec/spec_helper.rb

data/.rspec

@@ -1,2 +0,0 @@
---color
---format progress

data/spec/examples/bookings_spec.rb

@@ -1,72 +0,0 @@
-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)
-
-        ( parse_params(dirty_params) >> method(:read_bookings) ).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)
-        Success(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