fear 0.9.0 → 1.2.0

data/spec/fear/option/mixin_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Option::Mixin do
+  include Fear::Option::Mixin
+
+  describe "Option()" do
+    context "value is nil" do
+      subject { Option(nil) }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "value is not nil" do
+      subject { Option(42) }
+
+      it { is_expected.to eq(Fear.some(42)) }
+    end
+  end
+
+  describe "Some()" do
+    context "value is nil" do
+      subject { Some(nil) }
+
+      it { is_expected.to eq(Fear::Some.new(nil)) }
+    end
+
+    context "value is not nil" do
+      subject { Option(42) }
+
+      it { is_expected.to eq(Fear::Some.new(42)) }
+    end
+  end
+
+  describe "None()" do
+    subject { None() }
+
+    it { is_expected.to eq(Fear::None) }
+  end
+end

data/spec/fear/option_pattern_match_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::OptionPatternMatch do
+  context "Some" do
+    let(:matcher) do
+      described_class.new do |m|
+        m.some(:even?.to_proc) { |x| "#{x} is even" }
+        m.some(:odd?.to_proc) { |x| "#{x} is odd" }
+      end
+    end
+
+    it do
+      expect(matcher.(Fear.some(4))).to eq("4 is even")
+      expect(matcher.(Fear.some(3))).to eq("3 is odd")
+      expect do
+        matcher.(Fear.none)
+      end.to raise_error(Fear::MatchError)
+    end
+  end
+
+  context "None" do
+    let(:matcher) do
+      described_class.new do |m|
+        m.none { "nil" }
+      end
+    end
+
+    it do
+      expect(matcher.(Fear.none)).to eq("nil")
+      expect do
+        matcher.(Fear.some(3))
+      end.to raise_error(Fear::MatchError)
+    end
+  end
+end

data/spec/fear/option_pattern_matching_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Option do
+  describe "pattern matching" do
+    subject do
+      case value
+      in Fear::Some(Integer => int)
+        "some of #{int}"
+      in Fear::None
+        "none"
+      else
+        "something else"
+      end
+    end
+
+    context "when value is some of integer" do
+      let(:value) { Fear.some(42) }
+
+      it { is_expected.to eq("some of 42") }
+    end
+
+    context "when value is none" do
+      let(:value) { Fear.none }
+
+      it { is_expected.to eq("none") }
+    end
+
+    context "when value is not some of integer" do
+      let(:value) { Fear.some("42") }
+
+      it { is_expected.to eq("something else") }
+    end
+  end
+end

data/spec/fear/option_spec.rb

@@ -1,15 +1,128 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Option do
-  include Fear::Option::Mixin
+  describe "#zip" do
+    subject { left.zip(right) }
+
+    context "some with some" do
+      let(:left) { Fear.some(42) }
+      let(:right) { Fear.some(664) }
+
+      context "without a block" do
+        subject { left.zip(right) }
+
+        it { is_expected.to eq(Fear.some([42, 664])) }
+      end
+
+      context "with a block" do
+        subject { left.zip(right) { |x, y| x * y } }
+
+        it { is_expected.to eq(Fear.some(27_888)) }
+      end
+    end
+
+    context "some with none" do
+      let(:left) { Fear.some(42) }
+      let(:right) { Fear.none }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "none with some" do
+      let(:left) { Fear.none }
+      let(:right) { Fear.some(42) }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "none with none" do
+      let(:left) { Fear.none }
+      let(:right) { Fear.none }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+  end
+
+  describe "#filter_map" do
+    subject { option.filter_map(&filter_map) }
+
+    context "some mapped to nil" do
+      let(:option) { Fear.some(42) }
+      let(:filter_map) { ->(*) { nil } }
+
+      it { is_expected.to be_none }
+    end
+
+    context "some mapped to false" do
+      let(:option) { Fear.some(42) }
+      let(:filter_map) { ->(*) { false } }
+
+      it { is_expected.to be_none }
+    end
 
-  describe '#Option()' do
-    context 'value is nil' do
-      subject { Option(nil) }
-      it { is_expected.to eq(None()) }
+    context "some mapped to true" do
+      let(:option) { Fear.some(42) }
+      let(:filter_map) { ->(*) { true } }
+
+      it { is_expected.to be_some_of(true) }
+    end
+
+    context "some mapped to another value" do
+      let(:option) { Fear.some(42) }
+      let(:filter_map) { ->(x) { x / 2 if x.even? } }
+
+      it { is_expected.to be_some_of(21) }
+    end
+
+    context "none" do
+      let(:option) { Fear.none }
+      let(:filter_map) { ->(x) { x / 2 } }
+
+      it { is_expected.to be_none }
+    end
+  end
+
+  describe "#matcher" do
+    subject(:result) { matcher.(value) }
+
+    let(:matcher) do
+      described_class.matcher do |m|
+        m.some { |x| "some of #{x}" }
+        m.none { "none" }
+      end
+    end
+
+    context "when matches some branch" do
+      let(:value) { Fear.some(42) }
+
+      it { is_expected.to eq("some of 42") }
+    end
+
+    context "when matches none branch" do
+      let(:value) { Fear.none }
+
+      it { is_expected.to eq("none") }
+    end
+  end
+
+  describe "#match" do
+    subject(:matcher) do
+      described_class.match(value) do |m|
+        m.some { |x| "some of #{x}" }
+        m.none { "none" }
+      end
+    end
+
+    context "when matches some branch" do
+      let(:value) { Fear.some(42) }
+
+      it { is_expected.to eq("some of 42") }
     end
 
-    context 'value is not nil' do
-      subject { Option(42) }
-      it { is_expected.to eq(Some(42)) }
+    context "when matches none branch" do
+      let(:value) { Fear.none }
+
+      it { is_expected.to eq("none") }
     end
   end
 end

data/spec/fear/partial_function/empty_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::PartialFunction::EMPTY do
+  describe "#defined?" do
+    subject { described_class.defined_at?(42) }
+
+    it { is_expected.to be(false) }
+  end
+
+  describe "#call" do
+    subject { -> { described_class.(42) } }
+
+    it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 42") }
+  end
+
+  describe "#call_or_else" do
+    subject { described_class.call_or_else(42, &default) }
+    let(:default) { ->(x) { "default: #{x}" } }
+
+    it { is_expected.to eq("default: 42") }
+  end
+
+  describe "#and_then" do
+    subject { described_class.and_then { |_x| "then" } }
+
+    it { is_expected.to eq(described_class) }
+  end
+
+  describe "#or_else" do
+    subject { described_class.or_else(other) }
+
+    let(:other) { Fear.case(proc { true }) { "other" } }
+
+    it { is_expected.to eq(other) }
+  end
+
+  it { is_expected.to be_kind_of(Fear::PartialFunction) }
+end

data/spec/fear/partial_function_and_then_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::PartialFunction, "#and_then" do
+  context "proc" do
+    subject(:pf_and_f) { partial_function.and_then(&function) }
+
+    let(:partial_function) { Fear.case(->(x) { x.even? }) { |x| "pf: #{x}" } }
+    let(:function) { ->(x) { "f: #{x}" } }
+
+    describe "#defined_at?" do
+      context "defined" do
+        subject { pf_and_f.defined_at?(4) }
+
+        it { is_expected.to eq(true) }
+      end
+
+      context "not defined" do
+        subject { pf_and_f.defined_at?(3) }
+
+        it { is_expected.to eq(false) }
+      end
+    end
+
+    describe "#call" do
+      context "defined" do
+        subject { pf_and_f.(4) }
+
+        it { is_expected.to eq("f: pf: 4") }
+      end
+
+      context "not defined" do
+        subject { -> { pf_and_f.(3) } }
+
+        it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 3") }
+      end
+    end
+
+    describe "#call_or_else" do
+      let(:fallback) { ->(x) { "fallback: #{x}" } }
+
+      context "defined" do
+        subject { pf_and_f.call_or_else(4, &fallback) }
+
+        it { is_expected.to eq("f: pf: 4") }
+      end
+
+      context "not defined" do
+        subject { pf_and_f.call_or_else(3, &fallback) }
+
+        it { is_expected.to eq("fallback: 3") }
+      end
+    end
+  end
+
+  context "partial function" do
+    subject(:first_and_then_second) { first.and_then(second) }
+
+    describe "#defined_at?" do
+      context "first defined, second defined on result of first" do
+        subject { first_and_then_second.defined_at?(6) }
+
+        let(:first) { Fear.case(->(x) { x.even? }) { |x| x / 2 } }
+        let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| x / 3 } }
+
+        it { is_expected.to eq(true) }
+      end
+
+      context "first defined, second not defined on result of first" do
+        subject { first_and_then_second.defined_at?(4) }
+
+        let(:first) { Fear.case(->(x) { x.even? }) { |x| x / 2 } }
+        let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| x / 3 } }
+
+        it { is_expected.to eq(false) }
+      end
+
+      context "first not defined" do
+        subject { first_and_then_second.defined_at?(3) }
+
+        let(:first) { Fear.case(->(x) { x.even? }) { |x| "first: #{x}" } }
+        let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| "second: #{x}" } }
+
+        it { is_expected.to eq(false) }
+      end
+    end
+
+    describe "#call" do
+      context "first defined, second defined on result of first" do
+        subject { first_and_then_second.(6) }
+
+        let(:first) { Fear.case(->(x) { x.even? }) { |x| x / 2 } }
+        let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| x / 3 } }
+
+        it { is_expected.to eq(1) }
+      end
+
+      context "first defined, second not defined on result of first" do
+        subject { -> { first_and_then_second.(4) } }
+
+        let(:first) { Fear.case(->(x) { x.even? }) { |x| x / 2 } }
+        let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| x / 3 } }
+
+        it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 2") }
+      end
+
+      context "first not defined" do
+        subject { -> { first_and_then_second.(3) } }
+
+        let(:first) { Fear.case(->(x) { x.even? }) { |x| "first: #{x}" } }
+        let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| "second: #{x}" } }
+
+        it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 3") }
+      end
+    end
+
+    describe "#call_or_else" do
+      let(:fallback) { ->(x) { "fallback: #{x}" } }
+
+      context "first defined, second defined on result of first" do
+        subject { first_and_then_second.call_or_else(6, &fallback) }
+
+        let(:first) { Fear.case(->(x) { x.even? }) { |x| x / 2 } }
+        let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| x / 3 } }
+
+        it { is_expected.to eq(1) }
+      end
+
+      context "first defined, second not defined on result of first" do
+        subject { first_and_then_second.call_or_else(4, &fallback) }
+
+        let(:first) { Fear.case(->(x) { x.even? }) { |x| x / 2 } }
+        let(:second) { Fear.case(->(x) { x % 3 == 0 }) { |x| x / 3 } }
+
+        it { is_expected.to eq("fallback: 4") }
+      end
+
+      context "first not defined" do
+        subject { first_and_then_second.call_or_else(3, &fallback) }
+
+        let(:first) { Fear.case(->(x) { x.even? }) { |x| "first: #{x}" } }
+        let(:second) { Fear.case { |x| "second: #{x}" } }
+
+        it { is_expected.to eq("fallback: 3") }
+      end
+    end
+  end
+end

data/spec/fear/partial_function_composition_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# This file contains tests from
+# https://github.com/scala/scala/blob/2.13.x/test/junit/scala/PartialFunctionCompositionTest.scala
+RSpec.describe Fear::PartialFunction do
+  let(:fallback_fun) { ->(_) { "fallback" } }
+  let(:pass_all) { Fear.case(proc { true }) { |x| x } }
+  let(:pass_short) { Fear.case(->(x) { x.length < 5 }) { |x| x } }
+  let(:pass_pass) { Fear.case(->(x) { x.include?("pass") }) { |x| x } }
+
+  let(:all_and_then_short) { pass_all & pass_short }
+  let(:short_and_then_all) { pass_short & pass_all }
+  let(:all_and_then_pass) { pass_all & pass_pass }
+  let(:pass_and_then_all) { pass_pass & pass_all }
+  let(:pass_and_then_short) { pass_pass & pass_short }
+  let(:short_and_then_pass) { pass_short & pass_pass }
+
+  it "#and_then" do
+    expect(all_and_then_short.call_or_else("pass", &fallback_fun)).to eq("pass")
+    expect(short_and_then_all.call_or_else("pass", &fallback_fun)).to eq("pass")
+    expect(all_and_then_short.defined_at?("pass")).to eq(true)
+    expect(short_and_then_all.defined_at?("pass")).to eq(true)
+
+    expect(all_and_then_pass.call_or_else("pass", &fallback_fun)).to eq("pass")
+    expect(pass_and_then_all.call_or_else("pass", &fallback_fun)).to eq("pass")
+    expect(all_and_then_pass.defined_at?("pass")).to eq(true)
+    expect(pass_and_then_all.defined_at?("pass")).to eq(true)
+
+    expect(all_and_then_pass.call_or_else("longpass", &fallback_fun)).to eq("longpass")
+    expect(pass_and_then_all.call_or_else("longpass", &fallback_fun)).to eq("longpass")
+    expect(all_and_then_pass.defined_at?("longpass")).to eq(true)
+    expect(pass_and_then_all.defined_at?("longpass")).to eq(true)
+
+    expect(all_and_then_short.call_or_else("longpass", &fallback_fun)).to eq("fallback")
+    expect(short_and_then_all.call_or_else("longpass", &fallback_fun)).to eq("fallback")
+    expect(all_and_then_short.defined_at?("longpass")).to eq(false)
+    expect(short_and_then_all.defined_at?("longpass")).to eq(false)
+
+    expect(all_and_then_pass.call_or_else("longstr", &fallback_fun)).to eq("fallback")
+    expect(pass_and_then_all.call_or_else("longstr", &fallback_fun)).to eq("fallback")
+    expect(all_and_then_pass.defined_at?("longstr")).to eq(false)
+    expect(pass_and_then_all.defined_at?("longstr")).to eq(false)
+
+    expect(pass_and_then_short.call_or_else("pass", &fallback_fun)).to eq("pass")
+    expect(short_and_then_pass.call_or_else("pass", &fallback_fun)).to eq("pass")
+    expect(pass_and_then_short.defined_at?("pass")).to eq(true)
+    expect(short_and_then_pass.defined_at?("pass")).to eq(true)
+
+    expect(pass_and_then_short.call_or_else("longpass", &fallback_fun)).to eq("fallback")
+    expect(short_and_then_pass.call_or_else("longpass", &fallback_fun)).to eq("fallback")
+    expect(pass_and_then_short.defined_at?("longpass")).to eq(false)
+    expect(short_and_then_pass.defined_at?("longpass")).to eq(false)
+
+    expect(short_and_then_pass.call_or_else("longstr", &fallback_fun)).to eq("fallback")
+    expect(pass_and_then_short.call_or_else("longstr", &fallback_fun)).to eq("fallback")
+    expect(short_and_then_pass.defined_at?("longstr")).to eq(false)
+    expect(pass_and_then_short.defined_at?("longstr")).to eq(false)
+  end
+
+  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 }),
+    )
+
+    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)
+  end
+
+  it "or else anh then" do
+    f1 = Fear.case(->(x) { x < 5 }) { 1 }
+    f2 = Fear.case(->(x) { x > 10 }) { 10 }
+    f3 = Fear.case { |x| x * 2 }
+
+    f5 = f1.and_then(f3).or_else(f2)
+
+    expect(f5.(11)).to eq(10)
+    expect(f5.(3)).to eq(2)
+  end
+end