fear 1.0.0 → 1.1.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/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

data/spec/fear/partial_function_or_else_spec.rb

@@ -1,273 +1,275 @@
-RSpec.describe Fear::PartialFunction, '#or_else' do
+# 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
+  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
+    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
+    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
+    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) }
+  describe "#call" do
+    context "first defined, second not" do
+      subject { first_or_else_second.(4) }
 
-      it { is_expected.to eq('first: 4') }
+      it { is_expected.to eq("first: 4") }
     end
 
-    context 'first not defined, second defined' do
-      subject { first_or_else_second.call(9) }
+    context "first not defined, second defined" do
+      subject { first_or_else_second.(9) }
 
-      it { is_expected.to eq('second: 9') }
+      it { is_expected.to eq("second: 9") }
     end
 
-    context 'first not defined, second not defined' do
-      subject { -> { first_or_else_second.call(5) } }
+    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') }
+      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) }
+    context "first and second defined" do
+      subject { first_or_else_second.(6) }
 
-      it { is_expected.to eq('first: 6') }
+      it { is_expected.to eq("first: 6") }
     end
   end
 
-  describe '#call_or_else' do
+  describe "#call_or_else" do
     let(:fallback) { ->(x) { "fallback: #{x}" } }
 
-    context 'first defined, second not' do
+    context "first defined, second not" do
       subject { first_or_else_second.call_or_else(4, &fallback) }
 
-      it { is_expected.to eq('first: 4') }
+      it { is_expected.to eq("first: 4") }
     end
 
-    context 'first not defined, second defined' do
+    context "first not defined, second defined" do
       subject { first_or_else_second.call_or_else(9, &fallback) }
 
-      it { is_expected.to eq('second: 9') }
+      it { is_expected.to eq("second: 9") }
     end
 
-    context 'first not defined, second not defined' do
+    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') }
+      it { is_expected.to eq("fallback: 5") }
     end
 
-    context 'first and second defined' do
+    context "first and second defined" do
       subject { first_or_else_second.call_or_else(6, &fallback) }
 
-      it { is_expected.to eq('first: 6') }
+      it { is_expected.to eq("first: 6") }
     end
   end
 
-  describe '#or_else' do
+  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
+    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
+      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
+      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
+      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
+      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) }
+    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') }
+        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) }
+      context "first not defined, second defined" do
+        subject { first_or_else_second_or_else_third.(9) }
 
-        it { is_expected.to eq('second: 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) }
+      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') }
+        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) } }
+      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') }
+        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) }
+      context "first, second and third defined" do
+        subject { first_or_else_second.(42) }
 
-        it { is_expected.to eq('first: 42') }
+        it { is_expected.to eq("first: 42") }
       end
     end
 
-    describe '#call_or_else' do
+    describe "#call_or_else" do
       let(:fallback) { ->(x) { "fallback: #{x}" } }
 
-      context 'first defined, second not' do
+      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') }
+        it { is_expected.to eq("first: 4") }
       end
 
-      context 'first not defined, second defined' do
+      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') }
+        it { is_expected.to eq("second: 9") }
       end
 
-      context 'first not defined, second not defined, third defined' do
+      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') }
+        it { is_expected.to eq("third: 7") }
       end
 
-      context 'first not defined, second not defined, third not defined' do
+      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') }
+        it { is_expected.to eq("fallback: 1") }
       end
 
-      context 'first, second and third defined' do
+      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') }
+        it { is_expected.to eq("first: 42") }
       end
     end
   end
 
-  describe '#and_then' do
+  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
+    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
+      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
+      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
+      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) }
+    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') }
+        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) }
+      context "first not defined, second defined" do
+        subject { first_or_else_second_and_then_function.(3) }
 
-        it { is_expected.to eq('f: second: 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) } }
+      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') }
+        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) }
+      context "first defined, second defined" do
+        subject { first_or_else_second_and_then_function.(6) }
 
-        it { is_expected.to eq('f: first: 6') }
+        it { is_expected.to eq("f: first: 6") }
       end
     end
 
-    describe '#call_or_else' do
+    describe "#call_or_else" do
       let(:fallback) { ->(x) { "fallback: #{x}" } }
 
-      context 'first defined, second not' do
+      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') }
+        it { is_expected.to eq("f: first: 2") }
       end
 
-      context 'first not defined, second defined' do
+      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') }
+        it { is_expected.to eq("f: second: 3") }
       end
 
-      context 'first not defined, second not defined' do
+      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') }
+        it { is_expected.to eq("fallback: 5") }
       end
 
-      context 'first defined, second defined' do
+      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') }
+        it { is_expected.to eq("f: first: 6") }
       end
     end
   end