fear 1.0.0 → 2.0.0

data/spec/fear/partial_function_or_else_spec.rb

@@ -1,273 +1,275 @@
-RSpec.describe Fear::PartialFunction, '#or_else' do
+# frozen_string_literal: true
+
+RSpec.describe Fear::PartialFunction, "#or_else" do
   subject(:first_or_else_second) { first.or_else(second) }
 
   let(:first) { Fear.case(->(x) { x.even? }) { |x| "first: #{x}" } }
   let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| "second: #{x}" } }
 
-  describe '#defined_at?' do
-    context 'first defined, second not' do
+  describe "#defined_at?" do
+    context "first defined, second not" do
       subject { first_or_else_second.defined_at?(4) }
 
       it { is_expected.to eq(true) }
     end
 
-    context 'first not defined, second defined' do
+    context "first not defined, second defined" do
       subject { first_or_else_second.defined_at?(9) }
 
       it { is_expected.to eq(true) }
     end
 
-    context 'first not defined, second not defined' do
+    context "first not defined, second not defined" do
       subject { first_or_else_second.defined_at?(5) }
 
       it { is_expected.to eq(false) }
     end
 
-    context 'first and second defined' do
+    context "first and second defined" do
       subject { first_or_else_second.defined_at?(6) }
 
       it { is_expected.to eq(true) }
     end
   end
 
-  describe '#call' do
-    context 'first defined, second not' do
-      subject { first_or_else_second.call(4) }
+  describe "#call" do
+    context "first defined, second not" do
+      subject { first_or_else_second.(4) }
 
-      it { is_expected.to eq('first: 4') }
+      it { is_expected.to eq("first: 4") }
     end
 
-    context 'first not defined, second defined' do
-      subject { first_or_else_second.call(9) }
+    context "first not defined, second defined" do
+      subject { first_or_else_second.(9) }
 
-      it { is_expected.to eq('second: 9') }
+      it { is_expected.to eq("second: 9") }
     end
 
-    context 'first not defined, second not defined' do
-      subject { -> { first_or_else_second.call(5) } }
+    context "first not defined, second not defined" do
+      subject { -> { first_or_else_second.(5) } }
 
-      it { is_expected.to raise_error(Fear::MatchError, 'partial function not defined at: 5') }
+      it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 5") }
     end
 
-    context 'first and second defined' do
-      subject { first_or_else_second.call(6) }
+    context "first and second defined" do
+      subject { first_or_else_second.(6) }
 
-      it { is_expected.to eq('first: 6') }
+      it { is_expected.to eq("first: 6") }
     end
   end
 
-  describe '#call_or_else' do
+  describe "#call_or_else" do
     let(:fallback) { ->(x) { "fallback: #{x}" } }
 
-    context 'first defined, second not' do
+    context "first defined, second not" do
       subject { first_or_else_second.call_or_else(4, &fallback) }
 
-      it { is_expected.to eq('first: 4') }
+      it { is_expected.to eq("first: 4") }
     end
 
-    context 'first not defined, second defined' do
+    context "first not defined, second defined" do
       subject { first_or_else_second.call_or_else(9, &fallback) }
 
-      it { is_expected.to eq('second: 9') }
+      it { is_expected.to eq("second: 9") }
     end
 
-    context 'first not defined, second not defined' do
+    context "first not defined, second not defined" do
       subject { first_or_else_second.call_or_else(5, &fallback) }
 
-      it { is_expected.to eq('fallback: 5') }
+      it { is_expected.to eq("fallback: 5") }
     end
 
-    context 'first and second defined' do
+    context "first and second defined" do
       subject { first_or_else_second.call_or_else(6, &fallback) }
 
-      it { is_expected.to eq('first: 6') }
+      it { is_expected.to eq("first: 6") }
     end
   end
 
-  describe '#or_else' do
+  describe "#or_else" do
     let(:first_or_else_second_or_else_third) { first_or_else_second.or_else(third) }
     let(:third) { Fear.case(->(x) { x % 7 == 0 }) { |x| "third: #{x}" } }
 
-    describe '#defined_at?' do
-      context 'first defined, second not' do
+    describe "#defined_at?" do
+      context "first defined, second not" do
         subject { first_or_else_second_or_else_third.defined_at?(4) }
 
         it { is_expected.to eq(true) }
       end
 
-      context 'first not defined, second defined' do
+      context "first not defined, second defined" do
         subject { first_or_else_second_or_else_third.defined_at?(9) }
 
         it { is_expected.to eq(true) }
       end
 
-      context 'first not defined, second not defined, third defined' do
+      context "first not defined, second not defined, third defined" do
         subject { first_or_else_second_or_else_third.defined_at?(7) }
 
         it { is_expected.to eq(true) }
       end
 
-      context 'first not defined, second not defined, third not defined' do
+      context "first not defined, second not defined, third not defined" do
         subject { first_or_else_second_or_else_third.defined_at?(1) }
 
         it { is_expected.to eq(false) }
       end
 
-      context 'first, second and third defined' do
+      context "first, second and third defined" do
         subject { first_or_else_second.defined_at?(42) }
 
         it { is_expected.to eq(true) }
       end
     end
 
-    describe '#call' do
-      context 'first defined, second not' do
-        subject { first_or_else_second_or_else_third.call(4) }
+    describe "#call" do
+      context "first defined, second not" do
+        subject { first_or_else_second_or_else_third.(4) }
 
-        it { is_expected.to eq('first: 4') }
+        it { is_expected.to eq("first: 4") }
       end
 
-      context 'first not defined, second defined' do
-        subject { first_or_else_second_or_else_third.call(9) }
+      context "first not defined, second defined" do
+        subject { first_or_else_second_or_else_third.(9) }
 
-        it { is_expected.to eq('second: 9') }
+        it { is_expected.to eq("second: 9") }
       end
 
-      context 'first not defined, second not defined, third defined' do
-        subject { first_or_else_second_or_else_third.call(7) }
+      context "first not defined, second not defined, third defined" do
+        subject { first_or_else_second_or_else_third.(7) }
 
-        it { is_expected.to eq('third: 7') }
+        it { is_expected.to eq("third: 7") }
       end
 
-      context 'first not defined, second not defined, third not defined' do
-        subject { -> { first_or_else_second_or_else_third.call(1) } }
+      context "first not defined, second not defined, third not defined" do
+        subject { -> { first_or_else_second_or_else_third.(1) } }
 
-        it { is_expected.to raise_error(Fear::MatchError, 'partial function not defined at: 1') }
+        it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 1") }
       end
 
-      context 'first, second and third defined' do
-        subject { first_or_else_second.call(42) }
+      context "first, second and third defined" do
+        subject { first_or_else_second.(42) }
 
-        it { is_expected.to eq('first: 42') }
+        it { is_expected.to eq("first: 42") }
       end
     end
 
-    describe '#call_or_else' do
+    describe "#call_or_else" do
       let(:fallback) { ->(x) { "fallback: #{x}" } }
 
-      context 'first defined, second not' do
+      context "first defined, second not" do
         subject { first_or_else_second_or_else_third.call_or_else(4, &fallback) }
 
-        it { is_expected.to eq('first: 4') }
+        it { is_expected.to eq("first: 4") }
       end
 
-      context 'first not defined, second defined' do
+      context "first not defined, second defined" do
         subject { first_or_else_second_or_else_third.call_or_else(9, &fallback) }
 
-        it { is_expected.to eq('second: 9') }
+        it { is_expected.to eq("second: 9") }
       end
 
-      context 'first not defined, second not defined, third defined' do
+      context "first not defined, second not defined, third defined" do
         subject { first_or_else_second_or_else_third.call_or_else(7, &fallback) }
 
-        it { is_expected.to eq('third: 7') }
+        it { is_expected.to eq("third: 7") }
       end
 
-      context 'first not defined, second not defined, third not defined' do
+      context "first not defined, second not defined, third not defined" do
         subject { first_or_else_second_or_else_third.call_or_else(1, &fallback) }
 
-        it { is_expected.to eq('fallback: 1') }
+        it { is_expected.to eq("fallback: 1") }
       end
 
-      context 'first, second and third defined' do
+      context "first, second and third defined" do
         subject { first_or_else_second_or_else_third.call_or_else(42, &fallback) }
 
-        it { is_expected.to eq('first: 42') }
+        it { is_expected.to eq("first: 42") }
       end
     end
   end
 
-  describe '#and_then' do
+  describe "#and_then" do
     let(:first_or_else_second_and_then_function) { first_or_else_second.and_then(&function) }
     let(:function) { ->(x) { "f: #{x}" } }
 
-    describe '#defined_at?' do
-      context 'first defined, second not' do
+    describe "#defined_at?" do
+      context "first defined, second not" do
         subject { first_or_else_second_and_then_function.defined_at?(2) }
 
         it { is_expected.to eq(true) }
       end
 
-      context 'first not defined, second defined' do
+      context "first not defined, second defined" do
         subject { first_or_else_second_and_then_function.defined_at?(3) }
 
         it { is_expected.to eq(true) }
       end
 
-      context 'first not defined, second not defined' do
+      context "first not defined, second not defined" do
         subject { first_or_else_second_and_then_function.defined_at?(5) }
 
         it { is_expected.to eq(false) }
       end
 
-      context 'first defined, second defined' do
+      context "first defined, second defined" do
         subject { first_or_else_second_and_then_function.defined_at?(6) }
 
         it { is_expected.to eq(true) }
       end
     end
 
-    describe '#call' do
-      context 'first defined, second not' do
-        subject { first_or_else_second_and_then_function.call(2) }
+    describe "#call" do
+      context "first defined, second not" do
+        subject { first_or_else_second_and_then_function.(2) }
 
-        it { is_expected.to eq('f: first: 2') }
+        it { is_expected.to eq("f: first: 2") }
       end
 
-      context 'first not defined, second defined' do
-        subject { first_or_else_second_and_then_function.call(3) }
+      context "first not defined, second defined" do
+        subject { first_or_else_second_and_then_function.(3) }
 
-        it { is_expected.to eq('f: second: 3') }
+        it { is_expected.to eq("f: second: 3") }
       end
 
-      context 'first not defined, second not defined' do
-        subject { -> { first_or_else_second_and_then_function.call(5) } }
+      context "first not defined, second not defined" do
+        subject { -> { first_or_else_second_and_then_function.(5) } }
 
-        it { is_expected.to raise_error(Fear::MatchError, 'partial function not defined at: 5') }
+        it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 5") }
       end
 
-      context 'first defined, second defined' do
-        subject { first_or_else_second_and_then_function.call(6) }
+      context "first defined, second defined" do
+        subject { first_or_else_second_and_then_function.(6) }
 
-        it { is_expected.to eq('f: first: 6') }
+        it { is_expected.to eq("f: first: 6") }
       end
     end
 
-    describe '#call_or_else' do
+    describe "#call_or_else" do
       let(:fallback) { ->(x) { "fallback: #{x}" } }
 
-      context 'first defined, second not' do
+      context "first defined, second not" do
         subject { first_or_else_second_and_then_function.call_or_else(2, &fallback) }
 
-        it { is_expected.to eq('f: first: 2') }
+        it { is_expected.to eq("f: first: 2") }
       end
 
-      context 'first not defined, second defined' do
+      context "first not defined, second defined" do
         subject { first_or_else_second_and_then_function.call_or_else(3, &fallback) }
 
-        it { is_expected.to eq('f: second: 3') }
+        it { is_expected.to eq("f: second: 3") }
       end
 
-      context 'first not defined, second not defined' do
+      context "first not defined, second not defined" do
         subject { first_or_else_second_and_then_function.call_or_else(5, &fallback) }
 
-        it { is_expected.to eq('fallback: 5') }
+        it { is_expected.to eq("fallback: 5") }
       end
 
-      context 'first defined, second defined' do
+      context "first defined, second defined" do
         subject { first_or_else_second_and_then_function.call_or_else(6, &fallback) }
 
-        it { is_expected.to eq('f: first: 6') }
+        it { is_expected.to eq("f: first: 6") }
       end
     end
   end

data/spec/fear/partial_function_spec.rb

@@ -1,36 +1,26 @@
-RSpec.describe Fear::PartialFunction do
-  describe 'Fear.case()' do
-    context 'condition is extractor' do
-      subject do
-        Fear.xcase('[1, [2, second_of_second, *], 3, *rest]') do |second_of_second:, rest:|
-          [second_of_second, rest]
-        end
-      end
-
-      it { is_expected.to be_defined_at([1, [2, 2, 3, 4], 3, 6, 7]) }
-      it { is_expected.not_to be_defined_at([1, [1, 3, 3, 4], 3, 6, 7]) }
-      it { is_expected.not_to be_defined_at([1, [1, 2, 3, 4], 4, 6, 7]) }
-    end
+# frozen_string_literal: true
 
-    context 'condition as symbol' do
+RSpec.describe Fear::PartialFunction do
+  describe "Fear.case()" do
+    context "condition as symbol" do
       subject { Fear.case(:even?) { |x| x } }
 
-      it 'matches against the same symbol' do
+      it "matches against the same symbol" do
         is_expected.to be_defined_at(:even?)
         is_expected.not_to be_defined_at(3)
       end
     end
 
-    context 'condition as Class' do
+    context "condition as Class" do
       subject { Fear.case(Integer) { |x| x } }
 
       it do
         is_expected.to be_defined_at(4)
-        is_expected.not_to be_defined_at('3')
+        is_expected.not_to be_defined_at("3")
       end
     end
 
-    context 'condition as Proc' do
+    context "condition as Proc" do
       subject { Fear.case(->(x) { x.even? }) { |x| x } }
 
       it do
@@ -39,19 +29,19 @@ RSpec.describe Fear::PartialFunction do
       end
     end
 
-    context 'multiple condition' do
+    context "multiple condition" do
       subject { Fear.case(Integer, :even?.to_proc, ->(x) { x % 3 == 0 }) { |x| x } }
 
       it do
         is_expected.to be_defined_at(12)
         is_expected.not_to be_defined_at(12.0)
-        is_expected.not_to be_defined_at('3')
+        is_expected.not_to be_defined_at("3")
         is_expected.not_to be_defined_at(3)
         is_expected.not_to be_defined_at(4)
       end
     end
 
-    context 'multiple condition 2' do
+    context "multiple condition 2" do
       subject { Fear.case(Integer, 4) { |x| x } }
 
       it do
@@ -61,127 +51,167 @@ RSpec.describe Fear::PartialFunction do
     end
   end
 
-  describe '#lift' do
+  describe ".or" do
+    subject { described_class.or(guard_1, guard_2, &:itself) }
+
+    let(:guard_1) { ->(x) { x == 42 } }
+    let(:guard_2) { ->(x) { x == 21 } }
+
+    it { is_expected.to be_defined_at(42) }
+    it { is_expected.to be_defined_at(21) }
+    it { is_expected.not_to be_defined_at(20) }
+  end
+
+  describe ".and" do
+    subject { described_class.and(guard_1, guard_2, &:itself) }
+
+    let(:guard_1) { ->(x) { x % 5 == 0 } }
+    let(:guard_2) { ->(x) { x % 2 == 0 } }
+
+    it { is_expected.to be_defined_at(10) }
+    it { is_expected.not_to be_defined_at(5) }
+    it { is_expected.not_to be_defined_at(2) }
+    it { is_expected.not_to be_defined_at(3) }
+  end
+
+  describe "#lift" do
     let(:lifted) { partial_function.lift }
 
     let(:partial_function) { Fear.case(->(v) { v != 0 }) { |x| 4 / x } }
 
-    context 'defined' do
-      subject { lifted.call(2) }
+    context "defined" do
+      subject { lifted.(2) }
 
       it { is_expected.to eq(Fear::Some.new(2)) }
     end
 
-    context 'not defined' do
-      subject { lifted.call(0) }
+    context "not defined" do
+      subject { lifted.(0) }
 
       it { is_expected.to eq(Fear::None) }
     end
   end
 
-  describe '#defined_at?' do
+  describe "#defined_at?" do
     let(:partial_function) { Fear.case(->(v) { v == 42 }) {} }
 
-    it 'defined at' do
+    it "defined at" do
       expect(partial_function.defined_at?(42)).to eq(true)
     end
 
-    it 'not defined at' do
+    it "not defined at" do
       expect(partial_function.defined_at?(24)).to eq(false)
     end
   end
 
-  describe '#call' do
+  describe "#call" do
     let(:partial_function) { Fear.case(->(v) { v != 0 }) { |x| 4 / x } }
 
-    context 'defined' do
-      subject { partial_function.call(2) }
+    context "defined" do
+      subject { partial_function.(2) }
 
       it { is_expected.to eq(2) }
     end
 
-    context 'not defined' do
-      subject { -> { partial_function.call(0) } }
+    context "not defined" do
+      subject { -> { partial_function.(0) } }
 
-      it { is_expected.to raise_error(Fear::MatchError, 'partial function not defined at: 0') }
-    end
-
-    context 'defined and condition is extractor' do
-      subject { partial_function.call([1, 2, 3, 4, 5]) }
-
-      let(:partial_function) do
-        Fear.xcase('[1, second, 3, *rest]') { |second:, rest:| [second, rest] }
-      end
-
-      it { is_expected.to eq([2, [4, 5]]) }
+      it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 0") }
     end
   end
 
-  describe '#to_proc', '#call' do
+  describe "#to_proc", "#call" do
     let(:partial_function) { Fear.case(->(v) { v != 0 }) { |x| 4 / x }.to_proc }
 
-    context 'defined' do
-      subject { partial_function.call(2) }
+    context "defined" do
+      subject { partial_function.(2) }
 
       it { is_expected.to eq(2) }
     end
 
-    context 'not defined' do
-      subject { -> { partial_function.call(0) } }
+    context "not defined" do
+      subject { -> { partial_function.(0) } }
 
-      it { is_expected.to raise_error(Fear::MatchError, 'partial function not defined at: 0') }
+      it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 0") }
     end
   end
 
-  describe '#call_or_else' do
+  describe "#call_or_else" do
     let(:default) { ->(x) { "division by #{x} impossible" } }
     let(:partial_function) { Fear.case(->(x) { x != 0 }) { |x| 4 / x } }
 
-    context 'defined' do
+    context "defined" do
       subject { partial_function.call_or_else(2, &default) }
 
       it { is_expected.to eq(2) }
     end
 
-    context 'not defined' do
+    context "not defined" do
       subject { partial_function.call_or_else(0, &default) }
 
-      it { is_expected.to eq('division by 0 impossible') }
+      it { is_expected.to eq("division by 0 impossible") }
     end
   end
 
-  describe '#and_then' do
+  describe "#and_then" do
     let(:partial_function) { Fear.case(->(v) { v == 42 }) {} }
     let(:and_then) { ->(x) { x } }
 
-    context 'block given, arguments not given' do
+    context "block given, arguments not given" do
       subject { -> { partial_function.and_then(&and_then) } }
 
       it { is_expected.not_to raise_error }
     end
 
-    context 'block given, argument given' do
+    context "block given, argument given" do
       subject { -> { partial_function.and_then(and_then, &and_then) } }
 
       it { is_expected.to raise_error(ArgumentError) }
     end
 
-    context 'block given, arguments given' do
+    context "block given, arguments given" do
       subject { -> { partial_function.and_then(and_then, 42, &and_then) } }
 
       it { is_expected.to raise_error(ArgumentError) }
     end
 
-    context 'block not given, arguments not given' do
+    context "block not given, arguments not given" do
       subject { -> { partial_function.and_then } }
 
       it { is_expected.to raise_error(ArgumentError) }
     end
 
-    context 'block net given, arguments given' do
+    context "block net given, arguments given" do
       subject { -> { partial_function.and_then(and_then) } }
 
       it { is_expected.not_to raise_error }
     end
   end
+
+  shared_examples "#or_else" do |method_name|
+    subject { is_even.__send__(method_name, is_odd).(value) }
+
+    let(:is_even) { Fear.case(:even?.to_proc) { |x| "#{x} is even" } }
+    let(:is_odd) { Fear.case(:odd?.to_proc) { |x| "#{x} is odd" } }
+
+    context "when left side is defined" do
+      let(:value) { 42 }
+
+      it { is_expected.to eq("42 is even") }
+    end
+
+    context "when left side is not defined" do
+      let(:value) { 21 }
+
+      it { is_expected.to eq("21 is odd") }
+    end
+  end
+
+  describe "#or_else" do
+    include_examples "#or_else", :or_else
+  end
+
+  describe "#|" do
+    include_examples "#or_else", :|
+  end
 end