fear 0.9.0 → 1.2.0

data/spec/fear/partial_function_or_else_spec.rb

@@ -0,0 +1,276 @@
+# 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
+      subject { first_or_else_second.defined_at?(4) }
+
+      it { is_expected.to eq(true) }
+    end
+
+    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
+      subject { first_or_else_second.defined_at?(5) }
+
+      it { is_expected.to eq(false) }
+    end
+
+    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.(4) }
+
+      it { is_expected.to eq("first: 4") }
+    end
+
+    context "first not defined, second defined" do
+      subject { first_or_else_second.(9) }
+
+      it { is_expected.to eq("second: 9") }
+    end
+
+    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") }
+    end
+
+    context "first and second defined" do
+      subject { first_or_else_second.(6) }
+
+      it { is_expected.to eq("first: 6") }
+    end
+  end
+
+  describe "#call_or_else" do
+    let(:fallback) { ->(x) { "fallback: #{x}" } }
+
+    context "first defined, second not" do
+      subject { first_or_else_second.call_or_else(4, &fallback) }
+
+      it { is_expected.to eq("first: 4") }
+    end
+
+    context "first not defined, second defined" do
+      subject { first_or_else_second.call_or_else(9, &fallback) }
+
+      it { is_expected.to eq("second: 9") }
+    end
+
+    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") }
+    end
+
+    context "first and second defined" do
+      subject { first_or_else_second.call_or_else(6, &fallback) }
+
+      it { is_expected.to eq("first: 6") }
+    end
+  end
+
+  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
+        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
+        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
+        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
+        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
+        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.(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) }
+
+        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) }
+
+        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) } }
+
+        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) }
+
+        it { is_expected.to eq("first: 42") }
+      end
+    end
+
+    describe "#call_or_else" do
+      let(:fallback) { ->(x) { "fallback: #{x}" } }
+
+      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") }
+      end
+
+      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") }
+      end
+
+      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") }
+      end
+
+      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") }
+      end
+
+      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") }
+      end
+    end
+  end
+
+  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
+        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
+        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
+        subject { first_or_else_second_and_then_function.defined_at?(5) }
+
+        it { is_expected.to eq(false) }
+      end
+
+      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.(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) }
+
+        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) } }
+
+        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) }
+
+        it { is_expected.to eq("f: first: 6") }
+      end
+    end
+
+    describe "#call_or_else" do
+      let(:fallback) { ->(x) { "fallback: #{x}" } }
+
+      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") }
+      end
+
+      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") }
+      end
+
+      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") }
+      end
+
+      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") }
+      end
+    end
+  end
+end

data/spec/fear/partial_function_spec.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+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
+
+    context "condition as symbol" do
+      subject { Fear.case(:even?) { |x| x } }
+
+      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
+      subject { Fear.case(Integer) { |x| x } }
+
+      it do
+        is_expected.to be_defined_at(4)
+        is_expected.not_to be_defined_at("3")
+      end
+    end
+
+    context "condition as Proc" do
+      subject { Fear.case(->(x) { x.even? }) { |x| x } }
+
+      it do
+        is_expected.to be_defined_at(4)
+        is_expected.not_to be_defined_at(3)
+      end
+    end
+
+    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(4)
+      end
+    end
+
+    context "multiple condition 2" do
+      subject { Fear.case(Integer, 4) { |x| x } }
+
+      it do
+        is_expected.to be_defined_at(4)
+        is_expected.not_to be_defined_at(3)
+      end
+    end
+  end
+
+  describe ".or" do
+    subject { described_class.or(guard_1, guard_2, &Fear::Utils::IDENTITY) }
+
+    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, &Fear::Utils::IDENTITY) }
+
+    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.(2) }
+
+      it { is_expected.to eq(Fear::Some.new(2)) }
+    end
+
+    context "not defined" do
+      subject { lifted.(0) }
+
+      it { is_expected.to eq(Fear::None) }
+    end
+  end
+
+  describe "#defined_at?" do
+    let(:partial_function) { Fear.case(->(v) { v == 42 }) {} }
+
+    it "defined at" do
+      expect(partial_function.defined_at?(42)).to eq(true)
+    end
+
+    it "not defined at" do
+      expect(partial_function.defined_at?(24)).to eq(false)
+    end
+  end
+
+  describe "#call" do
+    let(:partial_function) { Fear.case(->(v) { v != 0 }) { |x| 4 / x } }
+
+    context "defined" do
+      subject { partial_function.(2) }
+
+      it { is_expected.to eq(2) }
+    end
+
+    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.([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]]) }
+    end
+  end
+
+  describe "#to_proc", "#call" do
+    let(:partial_function) { Fear.case(->(v) { v != 0 }) { |x| 4 / x }.to_proc }
+
+    context "defined" do
+      subject { partial_function.(2) }
+
+      it { is_expected.to eq(2) }
+    end
+
+    context "not defined" do
+      subject { -> { partial_function.(0) } }
+
+      it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 0") }
+    end
+  end
+
+  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
+      subject { partial_function.call_or_else(2, &default) }
+
+      it { is_expected.to eq(2) }
+    end
+
+    context "not defined" do
+      subject { partial_function.call_or_else(0, &default) }
+
+      it { is_expected.to eq("division by 0 impossible") }
+    end
+  end
+
+  describe "#and_then" do
+    let(:partial_function) { Fear.case(->(v) { v == 42 }) {} }
+    let(:and_then) { ->(x) { x } }
+
+    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
+      subject { -> { partial_function.and_then(and_then, &and_then) } }
+
+      it { is_expected.to raise_error(ArgumentError) }
+    end
+
+    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
+      subject { -> { partial_function.and_then } }
+
+      it { is_expected.to raise_error(ArgumentError) }
+    end
+
+    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