fear 2.0.1 → 3.1.0

data/spec/fear/either/left_projection_spec.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Either::LeftProjection do
+  subject(:projection) { described_class.new(either) }
+
+  describe "#include?" do
+    context "on Fear::Right" do
+      let(:either) { Fear.right("value") }
+
+      it { is_expected.not_to include("value") }
+    end
+
+    context "on Fear::Left" do
+      let(:either) { Fear.left("value") }
+
+      it { is_expected.to include("value") }
+      it { is_expected.not_to include("another values") }
+    end
+  end
+
+  describe "#get_or_else" do
+    context "on Fear::Right" do
+      let(:either) { Fear.right("value") }
+
+      context "with block" do
+        subject { projection.get_or_else { "default" } }
+
+        it "returns default value" do
+          is_expected.to eq("default")
+        end
+      end
+
+      context "with default argument" do
+        subject { projection.get_or_else("default") }
+
+        it "returns default value" do
+          is_expected.to eq("default")
+        end
+      end
+
+      context "with false argument" do
+        subject { projection.get_or_else(false) }
+
+        it "returns default value" do
+          is_expected.to eq(false)
+        end
+      end
+
+      context "with nil argument" do
+        subject { projection.get_or_else(nil) }
+
+        it "returns default value" do
+          is_expected.to eq(nil)
+        end
+      end
+    end
+
+    context "on Fear::Left" do
+      let(:either) { Fear.left("value") }
+
+      context "with block" do
+        subject { projection.get_or_else { "default" } }
+
+        it "returns value" do
+          is_expected.to eq("value")
+        end
+      end
+
+      context "with default argument" do
+        subject { projection.get_or_else("default") }
+
+        it "returns value" do
+          is_expected.to eq("value")
+        end
+      end
+
+      context "with false argument" do
+        subject { projection.get_or_else(false) }
+
+        it "returns value" do
+          is_expected.to eq("value")
+        end
+      end
+
+      context "with nil argument" do
+        subject { projection.get_or_else(nil) }
+
+        it "returns value" do
+          is_expected.to eq("value")
+        end
+      end
+    end
+  end
+
+  describe "#each" do
+    context "on Fear::Right" do
+      let(:either) { Fear.right(42) }
+
+      it "does not yield control and returns either" do
+        expect do |block|
+          expect(projection.each(&block)).to eq(either)
+        end.not_to yield_control
+      end
+    end
+
+    context "on Fear::Left" do
+      let(:either) { Fear.left(42) }
+
+      it "yields block and return either" do
+        expect do |block|
+          expect(projection.each(&block)).to eq(either)
+        end.to yield_with_args(42)
+      end
+    end
+  end
+
+  describe "#map" do
+    subject { projection.map(&:length) }
+
+    context "on Fear::Right" do
+      let(:either) { Fear.right("value") }
+
+      it "returns self" do
+        is_expected.to eq(either)
+      end
+    end
+
+    context "on Fear::Left" do
+      let(:either) { Fear.left("value") }
+
+      it "perform transformation" do
+        is_expected.to be_left_of(5)
+      end
+    end
+  end
+
+  describe "#flat_map" do
+    context "on Fear::Right" do
+      subject { projection.flat_map { Fear.right(_1 * 2) } }
+
+      let(:either) { Fear.right("value") }
+
+      it "returns self" do
+        is_expected.to eq(either)
+      end
+    end
+
+    context "on Fear::Left" do
+      subject(:either) { Fear.left(21) }
+
+      context "block returns neither left, nor right" do
+        subject { proc { projection.flat_map { 42 } } }
+
+        it "fails with TypeError" do
+          is_expected.to raise_error(TypeError)
+        end
+      end
+
+      context "block returns Right" do
+        subject { projection.flat_map { |e| Fear.right(e * 2) } }
+
+        it "maps to block result" do
+          is_expected.to be_right_of(42)
+        end
+      end
+
+      context "block returns Left" do
+        subject { projection.flat_map { |e| Fear.left(e * 2) } }
+
+        it "maps to block result" do
+          is_expected.to be_left_of(42)
+        end
+      end
+    end
+  end
+
+  describe "#to_option" do
+    subject { projection.to_option }
+
+    context "on Fear::Right" do
+      let(:either) { Fear.right("value") }
+
+      it { is_expected.to be_none }
+    end
+
+    context "on Fear::Left" do
+      let(:either) { Fear.left("value") }
+
+      it { is_expected.to be_some_of("value") }
+    end
+  end
+
+  describe "#to_a" do
+    subject { projection.to_a }
+
+    context "on Fear::Right" do
+      let(:either) { Fear.right("value") }
+
+      it { is_expected.to eq([]) }
+    end
+
+    context "on Fear::Left" do
+      let(:either) { Fear.left("value") }
+
+      it { is_expected.to eq(["value"]) }
+    end
+  end
+
+  describe "#any?" do
+    subject { projection.any?(&predicate) }
+
+    context "on Fear::Right" do
+      let(:predicate) { ->(v) { v == "value" } }
+      let(:either) { Fear.right("value") }
+
+      it { is_expected.to eq(false) }
+    end
+
+    context "on Fear::Left" do
+      let(:either) { Fear.left("value") }
+
+      context "matches predicate" do
+        let(:predicate) { ->(v) { v == "value" } }
+
+        it { is_expected.to eq(true) }
+      end
+
+      context "does not match predicate" do
+        let(:predicate) { ->(v) { v != "value" } }
+
+        it { is_expected.to eq(false) }
+      end
+    end
+  end
+
+  describe "select" do
+    subject { projection.select(&predicate) }
+
+    context "on Fear::Right" do
+      let(:either) { Fear.right("value") }
+      let(:predicate) { ->(v) { v == "value" } }
+
+      it { is_expected.to be_right_of("value") }
+    end
+
+    context "on Fear::Left" do
+      let(:either) { Fear.left("value") }
+
+      context "predicate evaluates to true" do
+        let(:predicate) { ->(v) { v == "value" } }
+
+        it { is_expected.to be_left_of("value") }
+      end
+
+      context "predicate evaluates to false" do
+        let(:predicate) { ->(v) { v != "value" } }
+
+        it { is_expected.to be_right_of("value") }
+      end
+    end
+  end
+
+  describe "#find" do
+    subject { projection.find(&predicate) }
+
+    context "on Fear::Right" do
+      let(:either) { Fear.right("value") }
+      let(:predicate) { ->(v) { v == "value" } }
+
+      it { is_expected.to be_none }
+    end
+
+    context "on Fear::Left" do
+      let(:either) { Fear.left("value") }
+
+      context "predicate evaluates to true" do
+        let(:predicate) { ->(v) { v == "value" } }
+
+        it { is_expected.to be_some_of(either) }
+      end
+
+      context "predicate evaluates to false" do
+        let(:predicate) { ->(v) { v != "value" } }
+
+        it { is_expected.to be_none }
+      end
+    end
+  end
+end

data/spec/fear/{either_pattern_match_spec.rb → either/pattern_match_spec.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe Fear::EitherPatternMatch do
+RSpec.describe Fear::Either::PatternMatch do
   context "Right" do
     let(:matcher) do
       described_class.new do |m|
@@ -10,10 +10,10 @@ RSpec.describe Fear::EitherPatternMatch do
     end
 
     it do
-      expect(matcher.(Fear.right(4))).to eq("4 is even")
-      expect(matcher.(Fear.right(3))).to eq("3 is odd")
+      expect(matcher.call(Fear.right(4))).to eq("4 is even")
+      expect(matcher.call(Fear.right(3))).to eq("3 is odd")
       expect do
-        matcher.(Fear.left(44))
+        matcher.call(Fear.left(44))
       end.to raise_error(Fear::MatchError)
     end
   end
@@ -27,10 +27,10 @@ RSpec.describe Fear::EitherPatternMatch do
     end
 
     it do
-      expect(matcher.(Fear.left(4))).to eq("4 is even")
-      expect(matcher.(Fear.left(3))).to eq("3 is odd")
+      expect(matcher.call(Fear.left(4))).to eq("4 is even")
+      expect(matcher.call(Fear.left(3))).to eq("3 is odd")
       expect do
-        matcher.(Fear.right(44))
+        matcher.call(Fear.right(44))
       end.to raise_error(Fear::MatchError)
     end
   end

data/spec/fear/either_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe Fear::Either do
   describe "#matcher" do
-    subject(:result) { matcher.(value) }
+    subject(:result) { matcher.call(value) }
 
     let(:matcher) do
       described_class.matcher do |m|

data/spec/fear/left_spec.rb

@@ -77,7 +77,7 @@ RSpec.describe Fear::Left do
     subject do
       left.reduce(
         ->(left) { "Left: #{left}" },
-        ->(right) { "Right: #{right}" },
+        ->(right) { "Right: #{right}" }
       )
     end
 

data/spec/fear/{option_pattern_match_spec.rb → option/pattern_match_spec.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe Fear::OptionPatternMatch do
+RSpec.describe Fear::Option::PatternMatch do
   context "Some" do
     let(:matcher) do
       described_class.new do |m|
@@ -10,10 +10,10 @@ RSpec.describe Fear::OptionPatternMatch do
     end
 
     it do
-      expect(matcher.(Fear.some(4))).to eq("4 is even")
-      expect(matcher.(Fear.some(3))).to eq("3 is odd")
+      expect(matcher.call(Fear.some(4))).to eq("4 is even")
+      expect(matcher.call(Fear.some(3))).to eq("3 is odd")
       expect do
-        matcher.(Fear.none)
+        matcher.call(Fear.none)
       end.to raise_error(Fear::MatchError)
     end
   end
@@ -26,9 +26,9 @@ RSpec.describe Fear::OptionPatternMatch do
     end
 
     it do
-      expect(matcher.(Fear.none)).to eq("nil")
+      expect(matcher.call(Fear.none)).to eq("nil")
       expect do
-        matcher.(Fear.some(3))
+        matcher.call(Fear.some(3))
       end.to raise_error(Fear::MatchError)
     end
   end

data/spec/fear/option_spec.rb

@@ -62,7 +62,7 @@ RSpec.describe Fear::Option do
 
     context "some mapped to nil" do
       let(:option) { Fear.some(42) }
-      let(:filter_map) { ->(*) { nil } }
+      let(:filter_map) { ->(*) {} }
 
       it { is_expected.to be_none }
     end
@@ -97,7 +97,7 @@ RSpec.describe Fear::Option do
   end
 
   describe "#matcher" do
-    subject(:result) { matcher.(value) }
+    subject(:result) { matcher.call(value) }
 
     let(:matcher) do
       described_class.matcher do |m|

data/spec/fear/partial_function/any_spec.rb

@@ -18,8 +18,8 @@ RSpec.describe Fear::PartialFunction::Any do
   describe ".to_proc" do
     subject(:any_proc) { any.to_proc }
 
-    it { expect(any_proc.(42)).to eq(true) }
-    it { expect(any_proc.("foo")).to eq(true) }
-    it { expect(any_proc.(Object.new)).to eq(true) }
+    it { expect(any_proc.call(42)).to eq(true) }
+    it { expect(any_proc.call("foo")).to eq(true) }
+    it { expect(any_proc.call(Object.new)).to eq(true) }
   end
 end

data/spec/fear/partial_function/empty_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe Fear::PartialFunction::EMPTY do
+RSpec.describe Fear::PartialFunction::Empty do
   describe "#defined?" do
     subject { described_class.defined_at?(42) }
 
@@ -8,7 +8,7 @@ RSpec.describe Fear::PartialFunction::EMPTY do
   end
 
   describe "#call" do
-    subject { -> { described_class.(42) } }
+    subject { -> { described_class.call(42) } }
 
     it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 42") }
   end

data/spec/fear/partial_function_and_then_spec.rb

@@ -23,13 +23,13 @@ RSpec.describe Fear::PartialFunction, "#and_then" do
 
     describe "#call" do
       context "defined" do
-        subject { pf_and_f.(4) }
+        subject { pf_and_f.call(4) }
 
         it { is_expected.to eq("f: pf: 4") }
       end
 
       context "not defined" do
-        subject { -> { pf_and_f.(3) } }
+        subject { -> { pf_and_f.call(3) } }
 
         it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 3") }
       end
@@ -86,7 +86,7 @@ RSpec.describe Fear::PartialFunction, "#and_then" do
 
     describe "#call" do
       context "first defined, second defined on result of first" do
-        subject { first_and_then_second.(6) }
+        subject { first_and_then_second.call(6) }
 
         let(:first) { Fear.case(->(x) { x.even? }) { |x| x / 2 } }
         let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| x / 3 } }
@@ -95,7 +95,7 @@ RSpec.describe Fear::PartialFunction, "#and_then" do
       end
 
       context "first defined, second not defined on result of first" do
-        subject { -> { first_and_then_second.(4) } }
+        subject { -> { first_and_then_second.call(4) } }
 
         let(:first) { Fear.case(->(x) { x.even? }) { |x| x / 2 } }
         let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| x / 3 } }
@@ -104,7 +104,7 @@ RSpec.describe Fear::PartialFunction, "#and_then" do
       end
 
       context "first not defined" do
-        subject { -> { first_and_then_second.(3) } }
+        subject { -> { first_and_then_second.call(3) } }
 
         let(:first) { Fear.case(->(x) { x.even? }) { |x| "first: #{x}" } }
         let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| "second: #{x}" } }

data/spec/fear/partial_function_composition_spec.rb

@@ -60,13 +60,13 @@ RSpec.describe Fear::PartialFunction do
   it "two branches" do
     first_branch = Fear.case(Integer, &:itself).and_then(Fear.case(1) { "one" })
     second_branch = Fear.case(String, &:itself).and_then(
-      (Fear.case("zero") { 0 }).or_else(Fear.case("one") { 1 }),
+      (Fear.case("zero") { 0 }).or_else(Fear.case("one") { 1 })
     )
 
     full = first_branch.or_else(second_branch)
-    expect(full.(1)).to eq("one")
-    expect(full.("zero")).to eq(0)
-    expect(full.("one")).to eq(1)
+    expect(full.call(1)).to eq("one")
+    expect(full.call("zero")).to eq(0)
+    expect(full.call("one")).to eq(1)
   end
 
   it "or else anh then" do
@@ -76,7 +76,7 @@ RSpec.describe Fear::PartialFunction do
 
     f5 = f1.and_then(f3).or_else(f2)
 
-    expect(f5.(11)).to eq(10)
-    expect(f5.(3)).to eq(2)
+    expect(f5.call(11)).to eq(10)
+    expect(f5.call(3)).to eq(2)
   end
 end

data/spec/fear/partial_function_or_else_spec.rb

@@ -34,25 +34,25 @@ RSpec.describe Fear::PartialFunction, "#or_else" do
 
   describe "#call" do
     context "first defined, second not" do
-      subject { first_or_else_second.(4) }
+      subject { first_or_else_second.call(4) }
 
       it { is_expected.to eq("first: 4") }
     end
 
     context "first not defined, second defined" do
-      subject { first_or_else_second.(9) }
+      subject { first_or_else_second.call(9) }
 
       it { is_expected.to eq("second: 9") }
     end
 
     context "first not defined, second not defined" do
-      subject { -> { first_or_else_second.(5) } }
+      subject { -> { first_or_else_second.call(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.(6) }
+      subject { first_or_else_second.call(6) }
 
       it { is_expected.to eq("first: 6") }
     end
@@ -124,31 +124,31 @@ RSpec.describe Fear::PartialFunction, "#or_else" do
 
     describe "#call" do
       context "first defined, second not" do
-        subject { first_or_else_second_or_else_third.(4) }
+        subject { first_or_else_second_or_else_third.call(4) }
 
         it { is_expected.to eq("first: 4") }
       end
 
       context "first not defined, second defined" do
-        subject { first_or_else_second_or_else_third.(9) }
+        subject { first_or_else_second_or_else_third.call(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.(7) }
+        subject { first_or_else_second_or_else_third.call(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.(1) } }
+        subject { -> { first_or_else_second_or_else_third.call(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.(42) }
+        subject { first_or_else_second.call(42) }
 
         it { is_expected.to eq("first: 42") }
       end
@@ -221,25 +221,25 @@ RSpec.describe Fear::PartialFunction, "#or_else" do
 
     describe "#call" do
       context "first defined, second not" do
-        subject { first_or_else_second_and_then_function.(2) }
+        subject { first_or_else_second_and_then_function.call(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.(3) }
+        subject { first_or_else_second_and_then_function.call(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.(5) } }
+        subject { -> { first_or_else_second_and_then_function.call(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.(6) }
+        subject { first_or_else_second_and_then_function.call(6) }
 
         it { is_expected.to eq("f: first: 6") }
       end

data/spec/fear/partial_function_spec.rb

@@ -80,13 +80,13 @@ RSpec.describe Fear::PartialFunction do
     let(:partial_function) { Fear.case(->(v) { v != 0 }) { |x| 4 / x } }
 
     context "defined" do
-      subject { lifted.(2) }
+      subject { lifted.call(2) }
 
       it { is_expected.to eq(Fear::Some.new(2)) }
     end
 
     context "not defined" do
-      subject { lifted.(0) }
+      subject { lifted.call(0) }
 
       it { is_expected.to eq(Fear::None) }
     end
@@ -108,13 +108,13 @@ RSpec.describe Fear::PartialFunction do
     let(:partial_function) { Fear.case(->(v) { v != 0 }) { |x| 4 / x } }
 
     context "defined" do
-      subject { partial_function.(2) }
+      subject { partial_function.call(2) }
 
       it { is_expected.to eq(2) }
     end
 
     context "not defined" do
-      subject { -> { partial_function.(0) } }
+      subject { -> { partial_function.call(0) } }
 
       it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 0") }
     end
@@ -124,13 +124,13 @@ RSpec.describe Fear::PartialFunction do
     let(:partial_function) { Fear.case(->(v) { v != 0 }) { |x| 4 / x }.to_proc }
 
     context "defined" do
-      subject { partial_function.(2) }
+      subject { partial_function.call(2) }
 
       it { is_expected.to eq(2) }
     end
 
     context "not defined" do
-      subject { -> { partial_function.(0) } }
+      subject { -> { partial_function.call(0) } }
 
       it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 0") }
     end
@@ -189,7 +189,7 @@ RSpec.describe Fear::PartialFunction do
   end
 
   shared_examples "#or_else" do |method_name|
-    subject { is_even.__send__(method_name, is_odd).(value) }
+    subject { is_even.__send__(method_name, is_odd).call(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" } }

data/spec/fear/pattern_match_spec.rb

@@ -11,26 +11,26 @@ RSpec.describe Fear::PatternMatch do
     end
 
     context "Integer" do
-      subject { matcher.(4) }
+      subject { matcher.call(4) }
 
       it { is_expected.to eq("4 is int") }
     end
 
     context "String" do
-      subject { matcher.("4") }
+      subject { matcher.call("4") }
 
       it { is_expected.to eq("4 is str") }
     end
 
     context "Symbol" do
-      subject { matcher.(:a) }
+      subject { matcher.call(:a) }
 
       it { is_expected.to eq("a is something else") }
     end
   end
 
   context "else before other branches" do
-    subject { matcher.(4) }
+    subject { matcher.call(4) }
 
     let(:matcher) do
       described_class.new do |m|
@@ -43,7 +43,7 @@ RSpec.describe Fear::PatternMatch do
   end
 
   context "several else branches" do
-    subject { matcher.(4) }
+    subject { matcher.call(4) }
 
     let(:matcher) do
       described_class.new do |m|