fear 1.0.0 → 2.0.0

data/spec/fear/option/mixin_spec.rb

@@ -1,35 +1,37 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Option::Mixin do
   include Fear::Option::Mixin
 
-  describe 'Option()' do
-    context 'value is nil' do
+  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
+    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
+  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
+    context "value is not nil" do
       subject { Option(42) }
 
       it { is_expected.to eq(Fear::Some.new(42)) }
     end
   end
 
-  describe 'None()' do
+  describe "None()" do
     subject { None() }
 
     it { is_expected.to eq(Fear::None) }

data/spec/fear/option_pattern_match_spec.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::OptionPatternMatch do
-  context 'Some' do
+  context "Some" do
     let(:matcher) do
       described_class.new do |m|
         m.some(:even?.to_proc) { |x| "#{x} is even" }
@@ -8,25 +10,25 @@ RSpec.describe Fear::OptionPatternMatch do
     end
 
     it do
-      expect(matcher.call(Fear.some(4))).to eq('4 is even')
-      expect(matcher.call(Fear.some(3))).to eq('3 is odd')
+      expect(matcher.(Fear.some(4))).to eq("4 is even")
+      expect(matcher.(Fear.some(3))).to eq("3 is odd")
       expect do
-        matcher.call(Fear.none)
+        matcher.(Fear.none)
       end.to raise_error(Fear::MatchError)
     end
   end
 
-  context 'None' do
+  context "None" do
     let(:matcher) do
       described_class.new do |m|
-        m.none { 'nil' }
+        m.none { "nil" }
       end
     end
 
     it do
-      expect(matcher.call(Fear.none)).to eq('nil')
+      expect(matcher.(Fear.none)).to eq("nil")
       expect do
-        matcher.call(Fear.some(3))
+        matcher.(Fear.some(3))
       end.to raise_error(Fear::MatchError)
     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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Option do
+  describe "#zip" do
+    subject(:zip) { 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 "some with non-option" do
+      let(:left) { Fear.some(42) }
+      let(:right) { 42 }
+
+      it { expect { zip }.to raise_error(TypeError) }
+    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
+
+    context "none with non-option" do
+      let(:left) { Fear.none }
+      let(:right) { 42 }
+
+      it { expect { zip }.to raise_error(TypeError) }
+    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
+
+    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 "when matches none branch" do
+      let(:value) { Fear.none }
+
+      it { is_expected.to eq("none") }
+    end
+  end
+end

data/spec/fear/partial_function/any_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::PartialFunction::Any do
+  subject(:any) { described_class }
+
+  describe ".===" do
+    it { expect(any === 42).to eq(true) }
+    it { expect(any === "foo").to eq(true) }
+    it { expect(any === Object.new).to eq(true) }
+  end
+
+  describe ".==" do
+    it { expect(any == 42).to eq(true) }
+    it { expect(any == "foo").to eq(true) }
+    it { expect(any == Object.new).to eq(true) }
+  end
+
+  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) }
+  end
+end

data/spec/fear/partial_function/empty_spec.rb

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

data/spec/fear/partial_function_and_then_spec.rb

@@ -1,60 +1,62 @@
-RSpec.describe Fear::PartialFunction, '#and_then' do
-  context 'proc' do
+# 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
+    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
+      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) }
+    describe "#call" do
+      context "defined" do
+        subject { pf_and_f.(4) }
 
-        it { is_expected.to eq('f: pf: 4') }
+        it { is_expected.to eq("f: pf: 4") }
       end
 
-      context 'not defined' do
-        subject { -> { pf_and_f.call(3) } }
+      context "not defined" do
+        subject { -> { pf_and_f.(3) } }
 
-        it { is_expected.to raise_error(Fear::MatchError, 'partial function not defined at: 3') }
+        it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 3") }
       end
     end
 
-    describe '#call_or_else' do
+    describe "#call_or_else" do
       let(:fallback) { ->(x) { "fallback: #{x}" } }
 
-      context 'defined' do
+      context "defined" do
         subject { pf_and_f.call_or_else(4, &fallback) }
 
-        it { is_expected.to eq('f: pf: 4') }
+        it { is_expected.to eq("f: pf: 4") }
       end
 
-      context 'not defined' do
+      context "not defined" do
         subject { pf_and_f.call_or_else(3, &fallback) }
 
-        it { is_expected.to eq('fallback: 3') }
+        it { is_expected.to eq("fallback: 3") }
       end
     end
   end
 
-  context 'partial function' do
+  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
+    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 } }
@@ -63,7 +65,7 @@ RSpec.describe Fear::PartialFunction, '#and_then' do
         it { is_expected.to eq(true) }
       end
 
-      context 'first defined, second not defined on result of first' do
+      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 } }
@@ -72,7 +74,7 @@ RSpec.describe Fear::PartialFunction, '#and_then' do
         it { is_expected.to eq(false) }
       end
 
-      context 'first not defined' do
+      context "first not defined" do
         subject { first_and_then_second.defined_at?(3) }
 
         let(:first) { Fear.case(->(x) { x.even? }) { |x| "first: #{x}" } }
@@ -82,9 +84,9 @@ RSpec.describe Fear::PartialFunction, '#and_then' do
       end
     end
 
-    describe '#call' do
-      context 'first defined, second defined on result of first' do
-        subject { first_and_then_second.call(6) }
+    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 } }
@@ -92,29 +94,29 @@ RSpec.describe Fear::PartialFunction, '#and_then' do
         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) } }
+      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') }
+        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) } }
+      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') }
+        it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 3") }
       end
     end
 
-    describe '#call_or_else' do
+    describe "#call_or_else" do
       let(:fallback) { ->(x) { "fallback: #{x}" } }
 
-      context 'first defined, second defined on result of first' do
+      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 } }
@@ -123,22 +125,22 @@ RSpec.describe Fear::PartialFunction, '#and_then' do
         it { is_expected.to eq(1) }
       end
 
-      context 'first defined, second not defined on result of first' do
+      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') }
+        it { is_expected.to eq("fallback: 4") }
       end
 
-      context 'first not defined' do
+      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') }
+        it { is_expected.to eq("fallback: 3") }
       end
     end
   end

data/spec/fear/partial_function_composition_spec.rb

@@ -1,10 +1,12 @@
+# 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(: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(: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 }
@@ -13,68 +15,68 @@ RSpec.describe Fear::PartialFunction do
   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)
+  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("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_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_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(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("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(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)
+    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' })
+  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.call(1)).to eq('one')
-    expect(full.call('zero')).to eq(0)
-    expect(full.call('one')).to eq(1)
+    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
+  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)
+    expect(f5.(11)).to eq(10)
+    expect(f5.(3)).to eq(2)
   end
 end