deterministic 0.14.1 → 0.15.0

data/lib/deterministic/version.rb

@@ -1,3 +1,3 @@
 module Deterministic
-  VERSION = "0.14.1"
+  VERSION = "0.15.0"
 end

data/spec/examples/amount_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'deterministic/enum'
+
+Amount = Deterministic::enum {
+  Due(:amount)
+  Paid(:amount)
+  Info(:amount)
+}
+
+class Amount
+  def self.from_f(f)
+    f >= 0 ? Amount::Due.new(f) : Amount::Paid.new(-1 * f)
+  end
+end
+
+Deterministic::impl(Amount) {
+  def to_s
+    match {
+      Due(a)  { "%0.2f" % [a] }
+      Paid(a) { "-%0.2f" % [a] }
+      Info(a) { "(%0.2f)" % [a] }
+    }
+  end
+
+  def to_f
+    match {
+      Info(a) { 0 }
+      Due(a)  { a }
+      Paid(a) { -1 * a }
+    }
+  end
+
+  def +(other)
+    raise TypeError "Expected other to be an Amount, got #{other.class}" unless other.is_a? Amount
+
+    Amount.from_f(to_f + other.to_f)
+  end
+}
+
+describe Amount do
+  def Due(a);  Amount::Due.new(a);  end
+  def Paid(a); Amount::Paid.new(a); end
+  def Info(a); Amount::Info.new(a); end
+
+  it "due" do
+    amount = Amount::Due.new(100.2)
+    expect(amount.to_s).to eq "100.20"
+  end
+
+  it "paid" do
+    amount = Amount::Paid.new(100.1)
+    expect(amount.to_s).to eq "-100.10"
+  end
+
+  it "paid" do
+    amount = Amount::Info.new(100.31)
+    expect(amount.to_s).to eq "(100.31)"
+  end
+
+  it "+" do
+    expect(Due(10) + Paid(20)).to eq Paid(10)
+    expect(Due(10) + Paid(10)).to eq Due(0)
+    expect(Due(10) + Due(10)).to eq Due(20)
+    expect(Paid(10) + Paid(10)).to eq Paid(20)
+    expect(Paid(10) + Due(1) + Info(99)).to eq Paid(9)
+  end
+end

data/spec/examples/config_spec.rb

@@ -11,8 +11,8 @@ class ElasticSearchConfig
 
   def hosts
     Option.any?(proc_env["RESFINITY_LOG_CLIENT_ES_HOST"]).match {
-      some { |s| { hosts: s.split(/, */) } }
-      none { default_hosts }
+      Some(s) { { hosts: s.split(/, */) } }
+      None() { default_hosts }
     }
   end
 
@@ -31,6 +31,8 @@ private
 end
 
 describe ElasticSearchConfig do
+  pending("match exec context must have access to parents block binding context") {
+
   let(:cfg) { ElasticSearchConfig.new(environment, env) }
   context "test" do
     let(:environment) { "test" }
@@ -70,4 +72,5 @@ describe ElasticSearchConfig do
       specify { expect(cfg.hosts).to eq({ hosts: ["acc.resfinity.net:9200"] }) }
     end
   end
+}
 end

data/spec/examples/controller_spec.rb

@@ -9,7 +9,7 @@ module Deterministic
 end
 
 class BookingController
-  include Deterministic
+  include Deterministic::Prelude::Result
   include Deterministic::Procify
 
   Context = Struct.new(:booking, :ability, :format)

data/spec/examples/list.rb

@@ -0,0 +1,183 @@
+require 'deterministic/enum'
+
+List = Deterministic::enum {
+  Cons(:head, :tail)
+  Nil()
+}
+
+class List
+  def self.[](*ary)
+    ary.reverse.inject(Nil.new) { |xs, x| xs.append(x) }
+  end
+
+  def self.empty
+    @empty ||= Nil.new
+  end
+end
+
+Deterministic::impl(List) {
+  class EmptyListError < StandardError; end
+
+  def append(elem)
+    List::Cons.new(elem, self)
+  end
+
+  def null?
+    is_a? Nil
+  end
+
+  def first
+    match {
+      Cons(_, _) { |c| c }
+      Nil() { |n| n }
+    }
+  end
+
+  def last
+    match {
+      Cons(h, t, where { t.null? }) { |c| return c }
+      Cons(_, t) { t.last }
+      Nil() { |n| n }
+    }
+  end
+
+  def head
+    match {
+      Cons(h, _) { h }
+      Nil() { |n| n }
+    }
+  end
+
+  def tail
+    match {
+      Cons(_, t) { t }
+      Nil() { |n| raise EmptyListError }
+    }
+  end
+
+  def init
+    match {
+      Cons(h, t, where { |c| t.tail.null? } ) { |c| Cons.new(h, Nil.new) }
+      Cons(h, t) { |c| Cons.new(h, t.init) }
+      Nil() { raise EmptyListError }
+    }
+  end
+
+  def filter(&pred)
+    match {
+      Cons(h, t, where { pred.(h) }) { |c| Cons.new(h, t.filter(&pred)) }
+      Cons(_, t) { t.filter(&pred) }
+      Nil() { |n| n }
+    }
+  end
+
+  # The find function takes a predicate and a list and returns the first element in the list matching the predicate,
+  # or None if there is no such element.
+  def find(&pred)
+    match {
+      Nil() { Deterministic::Option::None.new }
+      Cons(h, t) { if pred.(h) then Deterministic::Option::Some.new(h) else t.find(&pred) end }
+    }
+  end
+
+  def length
+    match {
+      Cons(h, t) { 1 + t.length }
+      Nil() { 0 }
+    }
+  end
+
+  def map(&fn)
+    match {
+      Cons(h, t) { Cons.new(fn.(h), t.map(&fn)) }
+      Nil() { |n| n }
+    }
+  end
+
+  def sum
+    foldl(0, &:+)
+  end
+
+  def foldl(start, &fn)
+    match {
+      Nil() { start }
+      # foldl f z (x:xs) = foldl f (f z x) xs
+      Cons(h, t) { t.foldl(fn.(start, h), &fn) }
+    }
+  end
+
+  def foldl1(&fn)
+    match {
+      Nil() { raise EmptyListError }
+      Cons(h, t) { t.foldl(h, &fn)}
+    }
+  end
+
+  def foldr(start, &fn)
+    match {
+      Nil() { start }
+      # foldr f z (x:xs) = f x (foldr f z xs)
+      Cons(h, t) { fn.(h, t.foldr(start, &fn)) }
+    }
+  end
+
+  def foldr1(&fn)
+    match {
+      Nil() { raise EmptyListError }
+      Cons(h, t, where { t.null? }) { h }
+      # foldr1 f (x:xs) =  f x (foldr1 f xs)
+      Cons(h, t) { fn.(h, t.foldr1(&fn)) }
+    }
+  end
+
+  def take(n)
+    match {
+      Cons(h, t, where { n > 0 }) { Cons.new(h, t.take(n - 1))}
+      Cons(_, _) { Nil.new }
+      Nil() { raise EmptyListError}
+    }
+  end
+
+  def drop(n)
+    match {
+      Cons(h, t, where { n > 0 }) { t.drop(n - 1) }
+      Cons(_, _) { |c| c }
+      Nil() { raise EmptyListError}
+    }
+  end
+
+  def to_a
+    foldr([]) { |x, ary| ary << x }
+  end
+
+  def any?(&pred)
+    match {
+      Nil() { false }
+      Cons(h, t, where { t.null? }) { pred.(h) }
+      Cons(h, t) { pred.(h) || t.any?(&pred) }
+    }
+  end
+
+  def all?(&pred)
+    match {
+      Nil() { false }
+      Cons(h, t, where { t.null? }) { pred.(h) }
+      Cons(h, t)                    { pred.(h) && t.all?(&pred) }
+    }
+  end
+
+  def reverse
+    match {
+      Nil() { |n| n }
+      Cons(_, t, where { t.null? }) { |c| c }
+      Cons(h, t) { |c| Cons.new(c.last.head, c.init.reverse) }
+    }
+  end
+
+  def to_s(joiner = ", ")
+    match {
+      Nil() { "Nil" }
+      Cons(head, tail) { head.to_s + joiner + tail.to_s }
+    }
+  end
+}

data/spec/examples/list_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+require_relative 'list'
+
+describe List do
+  Nil  = List::Nil
+  Cons = List::Cons
+
+  subject(:list) { List[1] }
+
+  specify { expect(list).to eq Cons.new(1, Nil.new) }
+
+  context "match" do
+    it "catches ignores guards with non-matching clauses" do
+      expect(
+        list.match {
+          Nil()       { self }
+          Cons(h, t, where { h == 0 })  { h }
+          Cons(h, t)  { h }
+        }).to eq 1
+    end
+
+    it "catches matching guards" do
+      expect( # guard catched
+        list.match {
+          Nil() { raise "unreachable" }
+          Cons(h, t, where { h == 1 })  { h + 1 }
+          Cons(h, t)  { h }
+        }).to eq 2
+    end
+
+    it "raises an error when no match was made" do
+      expect {
+        list.match {
+          Cons(_, _, where { true == false }) { 1 }
+          Nil(where { true == false }) { 0 }
+        }
+      }.to raise_error(Deterministic::Enum::MatchError)
+    end
+
+    it "raises an error when the match is not exhaustive" do
+      expect {
+        list.match {
+          Cons(_, _) {}
+        }
+      }.to raise_error(Deterministic::Enum::MatchError)
+    end
+  end
+
+  it "empty" do
+    expect(List.empty.object_id).to eq List.empty.object_id
+  end
+
+  it "from_a" do
+    expect(List[21, 15, 9].to_s).to eq "21, 15, 9, Nil"
+  end
+
+  it "append" do
+    expect(List[1].append(2)).to eq Cons.new(2, Cons.new(1, Nil.new))
+  end
+
+  context "head" do
+    specify { expect(list.head).to eq 1 }
+  end
+
+  context "tail" do
+    subject(:list) { List[3, 9, 15, 21] }
+    specify { expect(list.tail.to_s).to eq "9, 15, 21, Nil" }
+  end
+
+  context "take" do
+    subject(:list) { List[3, 9, 15, 21] }
+    specify { expect(list.take(2).to_s).to eq "3, 9, Nil" }
+  end
+
+  context "drop" do
+    subject(:list) { List[3, 9, 15, 21] }
+    specify { expect(list.drop(2).to_s).to eq "15, 21, Nil" }
+  end
+
+  context "null" do
+    specify { expect(Nil.new).to be_null }
+    specify { expect(Cons.new(1, Nil.new)).not_to be_null }
+  end
+
+  context "length" do
+    subject(:list) { List[21, 15, 9, 3] }
+    specify { expect(list.length).to eq 4 }
+    specify { expect(Nil.new.length).to eq 0 }
+  end
+
+  context "filter" do
+    subject(:list) { List[3, 9, 15, 21] }
+    specify { expect(list.filter { |n| n < 10 }.to_s).to eq "3, 9, Nil" }
+    specify { expect(Nil.new.filter { |n| n < 10 }).to eq Nil.new }
+  end
+
+  context "map" do
+    subject(:list) { List[1, 2, 3, 4] }
+
+    specify { expect(list.map { |h, t| h + 1 }).to eq Cons.new(2, Cons.new(3, Cons.new(4, Cons.new(5, Nil.new)))) }
+  end
+
+  context "first & last" do
+    subject(:list) { List[9, 15, 21] }
+    specify { expect(list.first.head).to eq 9 }
+    specify { expect(list.last.head).to eq 21 }
+
+    specify { expect(Nil.new.first).to eq Nil.new }
+    specify { expect(Nil.new.last).to eq Nil.new }
+  end
+
+  context "init" do
+    subject(:list) { List[9, 15, 21] }
+    specify { expect(list.init.to_s).to eq "9, 15, Nil" }
+    specify { expect { Nil.new.init}.to raise_error EmptyListError }
+  end
+
+  it "foldl :: [a] -> b -> (b -> a -> b) -> b" do
+    list = List[21, 15, 9]
+    expect(list.foldl(0) { |b, a| a + b }).to eq (((0 + 21) + 15) + 9)
+    expect(list.foldl(0) { |b, a| b - a }).to eq (((0 - 21) - 15) - 9)
+    expect(Nil.new.foldl(0, &:+)).to eq 0
+  end
+
+  it "foldl1 :: [a] -> b -> (b -> a -> b) -> b" do
+    list = List[21, 15, 9]
+    expect(list.foldl1 { |b, a| a + b }).to eq ((21 + 15) + 9)
+    expect(list.foldl1 { |b, a| b - a }).to eq ((21 - 15) - 9)
+    expect { Nil.new.foldl1(&:+) }.to raise_error EmptyListError
+  end
+
+  it "foldr :: [a] -> b -> (b -> a -> b) -> b" do
+    list = List[21, 15, 9]
+    expect(list.foldr(0) { |b, a| a + b }).to eq (21 + (15 + (9 + 0)))
+    expect(list.foldr(0) { |b, a| b - a }).to eq (21 - (15 - (9 - 0)))
+    expect(Nil.new.foldr(0, &:+)).to eq 0
+  end
+
+  it "foldr1 :: [a] -> b -> (b -> a -> b) -> b" do
+    list = List[21, 15, 9, 3]
+    expect(list.foldr1 { |b, a| a + b }).to eq (21 + (15 + (9 + 3)))
+    expect(list.foldr1 { |b, a| b - a }).to eq (21 - (15 - (9 - 3)))
+    expect { Nil.new.foldr1(&:+) }.to raise_error EmptyListError
+  end
+
+  it "find :: [a] -> (a -> Bool) -> Option a" do
+    list = List[21, 15, 9]
+    expect(list.find { |a| a == 15 }).to eq Deterministic::Option::Some.new(15)
+    expect(list.find { |a| a == 1 }).to  eq Deterministic::Option::None.new
+  end
+
+  context "reverse" do
+    subject(:list) { List[9, 15, 21] }
+    specify { expect(list.reverse.first.head).to eq 21 }
+    specify { expect(list.to_s).to eq "9, 15, 21, Nil" }
+    specify { expect(list.reverse.to_s).to eq "21, 15, 9, Nil" }
+  end
+
+  context "to_a" do
+    subject(:list) { List[9, 15, 21] }
+    specify { expect(list.to_a).to eq [21, 15, 9] }
+  end
+
+  context "all?" do
+    subject(:list) { List[21, 15, 9] }
+    specify { expect(list.all? { |n| n.is_a?(Fixnum) }).to be_truthy }
+  end
+
+  context "any?" do
+    subject(:list) { List[21, 15, 9] }
+    specify { expect(list.any? { |n| n == 11 }).to be_falsey }
+    specify { expect(list.any? { |n| n == 15 }).to be_truthy }
+  end
+
+  it "inspect" do
+    list = List[9, 15, 21]
+    expect(list.inspect).to eq "Cons(head: 9, tail: Cons(head: 15, tail: Cons(head: 21, tail: Nil)))"
+    expect(Nil.new.inspect).to eq "Nil"
+  end
+
+  it "to_s" do
+    list = List[9, 15, 21]
+    expect(list.to_s).to eq "9, 15, 21, Nil"
+    expect(Nil.new.to_s).to eq "Nil"
+  end
+end