fear 1.0.0 → 2.0.0

data/spec/fear/guard_spec.rb

@@ -1,101 +1,213 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::PartialFunction::Guard do
-  context 'Class' do
-    context 'match' do
+  context "Class" do
+    context "match" do
       subject { Fear::PartialFunction::Guard.new(Integer) === 4 }
 
       it { is_expected.to eq(true) }
     end
 
-    context 'not match' do
-      subject { Fear::PartialFunction::Guard.new(Integer) === '4' }
+    context "not match" do
+      subject { Fear::PartialFunction::Guard.new(Integer) === "4" }
 
       it { is_expected.to eq(false) }
     end
   end
 
-  context 'Symbol' do
-    context 'match' do
+  context "Symbol" do
+    context "match" do
       subject { Fear::PartialFunction::Guard.new(:even?) === :even? }
 
       it { is_expected.to eq(true) }
     end
 
-    context 'not match' do
+    context "not match" do
       subject { Fear::PartialFunction::Guard.new(:even?) === 4 }
 
       it { is_expected.to eq(false) }
     end
   end
 
-  context 'Proc' do
-    context 'match' do
+  context "Proc" do
+    context "match" do
       subject { Fear::PartialFunction::Guard.new(->(x) { x.even? }) === 4 }
 
       it { is_expected.to eq(true) }
     end
 
-    context 'not match' do
+    context "not match" do
       subject { Fear::PartialFunction::Guard.new(->(x) { x.even? }) === 3 }
 
       it { is_expected.to eq(false) }
     end
   end
 
-  describe '.and' do
-    context 'match' do
+  describe ".and" do
+    context "match" do
       subject { guard === 4 }
       let(:guard) { Fear::PartialFunction::Guard.and([Integer, :even?.to_proc, ->(x) { x.even? }]) }
 
       it { is_expected.to eq(true) }
     end
 
-    context 'not match' do
+    context "not match" do
       subject { guard === 3 }
       let(:guard) { Fear::PartialFunction::Guard.and([Integer, :even?.to_proc, ->(x) { x.even? }]) }
 
       it { is_expected.to eq(false) }
     end
 
-    context 'empty array' do
+    context "empty array" do
       subject { guard === 4 }
       let(:guard) { Fear::PartialFunction::Guard.and([]) }
 
-      it 'matches any values' do
+      it "matches any values" do
         is_expected.to eq(true)
       end
     end
 
-    context 'short circuit' do
+    context "short circuit" do
       let(:guard) { Fear::PartialFunction::Guard.and([first, second, third]) }
       let(:first) { ->(_) { false } }
       let(:second) { ->(_) { raise } }
       let(:third) { ->(_) { raise } }
 
-      it 'does not call the second and the third' do
+      it "does not call the second and the third" do
         expect { guard === 4 }.not_to raise_error
       end
     end
+
+    context "with many arguments" do
+      let(:guard) { Fear::PartialFunction::Guard.and([guard_1, guard_2, guard_3, guard_4]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 6 == 0 } }
+      let(:guard_4) { ->(x) { x % 7 == 0 } }
+      let(:guard_4) { ->(x) { x % 8 == 0 } }
+
+      it { expect(guard === 3360).to eq(true) }
+      it { expect(guard === 10).to eq(false) }
+      it { expect(guard === 8).to eq(false) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 7).to eq(false) }
+      it { expect(guard === 6).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+    end
+
+    describe "#and" do
+      let(:guard) { guard_1_and_guard_2.and(guard_3) }
+      let(:guard_1_and_guard_2) { Fear::PartialFunction::Guard.and([guard_1, guard_2]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 6 == 0 } }
+
+      it { expect(guard === 30).to eq(true) }
+      it { expect(guard === 10).to eq(false) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+      it { expect(guard === 3).to eq(false) }
+    end
+
+    describe "#and", "with three arguments" do
+      let(:guard) { guard_123.and(guard_4) }
+      let(:guard_123) { Fear::PartialFunction::Guard.and([guard_1, guard_2, guard_3]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 6 == 0 } }
+      let(:guard_4) { ->(x) { x % 7 == 0 } }
+
+      it { expect(guard === 420).to eq(true) }
+      it { expect(guard === 10).to eq(false) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 7).to eq(false) }
+      it { expect(guard === 6).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+    end
+
+    describe "#or" do
+      let(:guard) { guard_1_and_guard_2.or(guard_3) }
+      let(:guard_1_and_guard_2) { Fear::PartialFunction::Guard.and([guard_1, guard_2]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 3 == 0 } }
+
+      it { expect(guard === 10).to eq(true) }
+      it { expect(guard === 3).to eq(true) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+      it { expect(guard === 7).to eq(false) }
+    end
+
+    describe "#or", "with three arguments" do
+      let(:guard) { guard_123.or(guard_4) }
+      let(:guard_123) { Fear::PartialFunction::Guard.and([guard_1, guard_2, guard_3]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 6 == 0 } }
+      let(:guard_4) { ->(x) { x % 7 == 0 } }
+
+      it { expect(guard === 30).to eq(true) }
+      it { expect(guard === 7).to eq(true) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+      it { expect(guard === 6).to eq(false) }
+    end
   end
 
-  describe '.or' do
-    let(:guard) { Fear::PartialFunction::Guard.or(['F', Integer]) }
+  describe ".or" do
+    let(:guard) { Fear::PartialFunction::Guard.or(["F", Integer]) }
 
-    context 'match second' do
+    context "match second" do
       subject { guard === 4 }
 
       it { is_expected.to eq(true) }
     end
 
-    context 'match first' do
-      subject { guard === 'F' }
+    context "match first" do
+      subject { guard === "F" }
 
       it { is_expected.to eq(true) }
     end
 
-    context 'not match' do
-      subject { guard === 'A&' }
+    context "not match" do
+      subject { guard === "A&" }
 
       it { is_expected.to eq(false) }
     end
+
+    describe "#and" do
+      let(:guard) { guard_1_or_guard_2.and(guard_3) }
+      let(:guard_1_or_guard_2) { Fear::PartialFunction::Guard.or([guard_1, guard_2]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 3 == 0 } }
+
+      it { expect(guard === 6).to eq(true) }
+      it { expect(guard === 15).to eq(true) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+      it { expect(guard === 3).to eq(false) }
+    end
+
+    describe "#or" do
+      let(:guard) { guard_1_or_guard_2.or(guard_3) }
+      let(:guard_1_or_guard_2) { Fear::PartialFunction::Guard.or([guard_1, guard_2]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 3 == 0 } }
+
+      it { expect(guard === 5).to eq(true) }
+      it { expect(guard === 2).to eq(true) }
+      it { expect(guard === 3).to eq(true) }
+      it { expect(guard === 7).to eq(false) }
+    end
   end
 end

data/spec/fear/left_spec.rb

@@ -1,77 +1,79 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Left do
   it_behaves_like Fear::RightBiased::Left do
-    let(:left) { Fear.left('value') }
+    let(:left) { Fear.left("value") }
   end
 
-  let(:left) { Fear.left('value') }
+  let(:left) { Fear.left("value") }
 
-  describe '#right?' do
+  describe "#right?" do
     subject { left }
     it { is_expected.not_to be_right }
   end
 
-  describe '#left?' do
+  describe "#left?" do
     subject { left }
     it { is_expected.to be_left }
   end
 
-  describe '#select_or_else' do
+  describe "#select_or_else" do
     subject do
-      left.select_or_else(default) { |v| v == 'value' }
+      left.select_or_else(default) { |v| v == "value" }
     end
 
-    context 'proc default' do
+    context "proc default" do
       let(:default) { -> { -1 } }
 
-      it 'returns itself' do
+      it "returns itself" do
         is_expected.to eq(left)
       end
     end
 
-    context 'default' do
+    context "default" do
       let(:default) { -1 }
 
-      it 'returns itself' do
+      it "returns itself" do
         is_expected.to eq(left)
       end
     end
   end
 
-  describe '#or_else' do
+  describe "#or_else" do
     subject { left.or_else { alternative } }
     let(:alternative) { Fear.left(42) }
 
-    it 'returns alternative' do
+    it "returns alternative" do
       is_expected.to eq(alternative)
     end
   end
 
-  describe '#select' do
+  describe "#select" do
     subject do
-      left.select { |v| v == 'value' }
+      left.select { |v| v == "value" }
     end
 
-    it 'return self' do
+    it "return self" do
       is_expected.to eq(left)
     end
   end
 
-  describe '#reject' do
+  describe "#reject" do
     subject do
-      left.reject { |v| v == 'value' }
+      left.reject { |v| v == "value" }
     end
 
-    it 'return self' do
+    it "return self" do
       is_expected.to eq(left)
     end
   end
 
-  describe '#swap' do
+  describe "#swap" do
     subject { left.swap }
-    it { is_expected.to eq(Fear.right('value')) }
+    it { is_expected.to eq(Fear.right("value")) }
   end
 
-  describe '#reduce' do
+  describe "#reduce" do
     subject do
       left.reduce(
         ->(left) { "Left: #{left}" },
@@ -79,69 +81,76 @@ RSpec.describe Fear::Left do
       )
     end
 
-    it { is_expected.to eq('Left: value') }
+    it { is_expected.to eq("Left: value") }
   end
 
-  describe '#join_right' do
+  describe "#join_right" do
     subject(:join_right) { either.join_right }
 
-    context 'value is Either' do
-      let(:either) { described_class.new(Fear.left('error')) }
+    context "value is Either" do
+      let(:either) { described_class.new(Fear.left("error")) }
       it { is_expected.to eq(either) }
     end
 
-    context 'value s not Either' do
-      let(:either) { Fear.left('error') }
+    context "value s not Either" do
+      let(:either) { Fear.left("error") }
       it { is_expected.to eq(either) }
     end
   end
 
-  describe '#join_left' do
-    context 'value is Either' do
+  describe "#join_left" do
+    context "value is Either" do
       subject { either.join_left }
       let(:either) { described_class.new(value) }
-      let(:value) { Fear.left('error') }
+      let(:value) { Fear.left("error") }
 
-      it 'returns value' do
-        is_expected.to eq(Fear.left('error'))
+      it "returns value" do
+        is_expected.to eq(Fear.left("error"))
       end
     end
 
-    context 'value is not Either' do
+    context "value is not Either" do
       subject { proc { left.join_left } }
 
-      it 'fails with type error' do
+      it "fails with type error" do
         is_expected.to raise_error(TypeError)
       end
     end
   end
 
-  describe '#===' do
+  describe "#===" do
     subject { match === left }
 
-    context 'matches erectly' do
-      let(:match) { Fear.left('value') }
+    context "matches erectly" do
+      let(:match) { Fear.left("value") }
       it { is_expected.to eq(true) }
     end
 
-    context 'value does not match' do
-      let(:match) { Fear.left('error') }
+    context "value does not match" do
+      let(:match) { Fear.left("error") }
       it { is_expected.to eq(false) }
     end
 
-    context 'matches by class' do
+    context "matches by class" do
       let(:match) { Fear.left(String) }
       it { is_expected.to eq(true) }
     end
 
-    context 'does not matches by class' do
+    context "does not matches by class" do
       let(:match) { Fear.left(Integer) }
       it { is_expected.to eq(false) }
     end
+
+    context "does non-either" do
+      let(:match) { Fear.left(42) }
+      let(:left) { 42 }
+
+      it { is_expected.to eq(false) }
+    end
   end
 
-  describe '#match' do
-    context 'matched' do
+  describe "#match" do
+    context "matched" do
       subject do
         left.match do |m|
           m.left(->(x) { x.length < 2 }) { |x| "Left: #{x}" }
@@ -150,15 +159,15 @@ RSpec.describe Fear::Left do
         end
       end
 
-      it { is_expected.to eq('Left: value') }
+      it { is_expected.to eq("Left: value") }
     end
 
-    context 'nothing matched and no else given' do
+    context "nothing matched and no else given" do
       subject do
         proc do
           left.match do |m|
             m.left(->(x) { x.length < 2 }) { |x| "Left: #{x}" }
-            m.right { |_| 'noop' }
+            m.right { |_| "noop" }
           end
         end
       end
@@ -166,7 +175,7 @@ RSpec.describe Fear::Left do
       it { is_expected.to raise_error(Fear::MatchError) }
     end
 
-    context 'nothing matched and else given' do
+    context "nothing matched and else given" do
       subject do
         left.match do |m|
           m.left(->(x) { x.length < 2 }) { |x| "Left: #{x}" }
@@ -178,31 +187,9 @@ RSpec.describe Fear::Left do
     end
   end
 
-  describe '#to_s' do
+  describe "#to_s" do
     subject { left.to_s }
 
     it { is_expected.to eq('#<Fear::Left value="value">') }
   end
-
-  describe 'pattern matching' do
-    subject { Fear.xcase('Left(v : Integer)') { |v:| "matched #{v}" }.call_or_else(var) { 'nothing' } }
-
-    context 'left of int' do
-      let(:var) { Fear.left(42) }
-
-      it { is_expected.to eq('matched 42') }
-    end
-
-    context 'left of string' do
-      let(:var) { Fear.left('42') }
-
-      it { is_expected.to eq('nothing') }
-    end
-
-    context 'not left' do
-      let(:var) { '42' }
-
-      it { is_expected.to eq('nothing') }
-    end
-  end
 end

data/spec/fear/none_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::None do
   it_behaves_like Fear::RightBiased::Left do
     let(:left) { Fear.none }
@@ -5,105 +7,115 @@ RSpec.describe Fear::None do
 
   subject(:none) { Fear.none }
 
-  describe '#get' do
+  describe "#get" do
     subject { proc { none.get } }
     it { is_expected.to raise_error(Fear::NoSuchElementError) }
   end
 
-  describe '#or_nil' do
+  describe "#or_nil" do
     subject { none.or_nil }
     it { is_expected.to eq(nil) }
   end
 
-  describe '#or_else' do
+  describe "#or_else" do
     subject { none.or_else { alternative } }
     let(:alternative) { Fear.some(42) }
 
-    it 'returns alternative' do
+    it "returns alternative" do
       is_expected.to eq(alternative)
     end
   end
 
-  describe '#empty?' do
+  describe "#empty?" do
     subject { none.empty? }
     it { is_expected.to eq(true) }
   end
 
-  describe '#select' do
+  describe "#blank?" do
+    subject { none.blank? }
+    it { is_expected.to eq(true) }
+  end
+
+  describe "#present?" do
+    subject { none.present? }
+    it { is_expected.to be_falsey }
+  end
+
+  describe "#select" do
     subject { none.select { |value| value > 42 } }
 
-    it 'always return None' do
+    it "always return None" do
       is_expected.to eq(Fear.none)
     end
   end
 
-  describe '#reject' do
+  describe "#reject" do
     subject { none.reject { |value| value > 42 } }
 
-    it 'always return None' do
+    it "always return None" do
       is_expected.to eq(Fear.none)
     end
   end
 
-  describe '.new' do
+  describe ".new" do
     subject { Fear::None.class.new }
 
     it { is_expected.to eq(Fear::None) }
   end
 
-  describe '.inherited' do
+  describe ".inherited" do
     subject { -> { Class.new(Fear.none.class) } }
 
-    it 'raises error' do
-      is_expected.to raise_error(RuntimeError, 'you are not allowed to inherit from NoneClass, use Fear::None instead')
+    it "raises error" do
+      is_expected.to raise_error(RuntimeError, "you are not allowed to inherit from NoneClass, use Fear::None instead")
     end
   end
 
-  describe '#to_s' do
+  describe "#to_s" do
     subject { none.to_s }
 
-    it { is_expected.to eq('#<Fear::NoneClass>') }
+    it { is_expected.to eq("#<Fear::NoneClass>") }
   end
 
-  describe '#inspect' do
+  describe "#inspect" do
     subject { none.inspect }
 
-    it { is_expected.to eq('#<Fear::NoneClass>') }
+    it { is_expected.to eq("#<Fear::NoneClass>") }
   end
 
-  describe '#===' do
-    context 'None' do
+  describe "#===" do
+    context "None" do
       subject { Fear::None === none }
 
       it { is_expected.to eq(true) }
     end
 
-    context 'Fear::Some' do
+    context "Fear::Some" do
       subject { Fear::None === Fear.some(4) }
 
       it { is_expected.to eq(false) }
     end
 
-    context 'Integer' do
+    context "Integer" do
       subject { Fear::None === 4 }
 
       it { is_expected.to eq(false) }
     end
   end
 
-  describe '#match' do
-    context 'matched' do
+  describe "#match" do
+    context "matched" do
       subject do
         none.match do |m|
           m.some { |x| x * 2 }
-          m.none { 'noop' }
+          m.none { "noop" }
         end
       end
 
-      it { is_expected.to eq('noop') }
+      it { is_expected.to eq("noop") }
     end
 
-    context 'nothing matched and no else given' do
+    context "nothing matched and no else given" do
       subject do
         proc do
           none.match do |m|
@@ -115,7 +127,7 @@ RSpec.describe Fear::None do
       it { is_expected.to raise_error(Fear::MatchError) }
     end
 
-    context 'nothing matched and else given' do
+    context "nothing matched and else given" do
       subject do
         none.match do |m|
           m.some { |x| x * 2 }
@@ -126,20 +138,4 @@ RSpec.describe Fear::None do
       it { is_expected.to eq(:default) }
     end
   end
-
-  describe 'pattern matching' do
-    subject { Fear.xcase('None()') { 'matched' }.call_or_else(var) { 'nothing' } }
-
-    context 'none' do
-      let(:var) { Fear.none }
-
-      it { is_expected.to eq('matched') }
-    end
-
-    context 'not none' do
-      let(:var) { '42' }
-
-      it { is_expected.to eq('nothing') }
-    end
-  end
 end