fear 0.10.0 → 0.11.0

data/spec/fear/partial_function_and_then_spec.rb

@@ -0,0 +1,145 @@
+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.call(4) }
+
+        it { is_expected.to eq('f: pf: 4') }
+      end
+
+      context 'not defined' do
+        subject { -> { pf_and_f.call(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.call(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.call(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.call(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,80 @@
+# 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.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
+    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.call(11)).to eq(10)
+    expect(f5.call(3)).to eq(2)
+  end
+end

data/spec/fear/partial_function_or_else_spec.rb

@@ -0,0 +1,274 @@
+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.call(4) }
+
+      it { is_expected.to eq('first: 4') }
+    end
+
+    context 'first not defined, second defined' do
+      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.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.call(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.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.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.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.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.call(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.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.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.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.call(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,165 @@
+RSpec.describe Fear::PartialFunction do
+  describe 'Fear.case()' do
+    context 'condition as symbol' do
+      subject { Fear.case(:even?) { |x| x } }
+
+      it 'converted to proc' do
+        is_expected.to be_defined_at(4)
+        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?, ->(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 '#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) }
+
+      it { is_expected.to eq(Fear::Some.new(2)) }
+    end
+
+    context 'not defined' do
+      subject { lifted.call(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.call(2) }
+
+      it { is_expected.to eq(2) }
+    end
+
+    context 'not defined' do
+      subject { -> { partial_function.call(0) } }
+
+      it { is_expected.to raise_error(Fear::MatchError, 'partial function not defined at: 0') }
+    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.call(2) }
+
+      it { is_expected.to eq(2) }
+    end
+
+    context 'not defined' do
+      subject { -> { partial_function.call(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
+end