fear 1.0.0 → 2.0.0

data/spec/fear/either_pattern_matching_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Either do
+  describe "pattern matching" do
+    subject do
+      case value
+      in Fear::Right[Integer => int]
+        "right of #{int}"
+      in Fear::Left[Integer => int]
+        "left of #{int}"
+      else
+        "something else"
+      end
+    end
+
+    context "when value is right of integer" do
+      let(:value) { Fear.right(42) }
+
+      it { is_expected.to eq("right of 42") }
+    end
+
+    context "when value is left of integer" do
+      let(:value) { Fear.left(42) }
+
+      it { is_expected.to eq("left of 42") }
+    end
+  end
+end

data/spec/fear/either_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Either do
+  describe "#matcher" do
+    subject(:result) { matcher.(value) }
+
+    let(:matcher) do
+      described_class.matcher do |m|
+        m.right { |x| "right of #{x}" }
+        m.left { |x| "left of #{x}" }
+      end
+    end
+
+    context "when matches the right branch" do
+      let(:value) { Fear.right(42) }
+
+      it { is_expected.to eq("right of 42") }
+    end
+
+    context "when matches the left branch" do
+      let(:value) { Fear.left(42) }
+
+      it { is_expected.to eq("left of 42") }
+    end
+  end
+end

data/spec/fear/failure_spec.rb

@@ -1,155 +1,164 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Failure do
-  let(:exception) { RuntimeError.new('error') }
+  let(:exception) { RuntimeError.new("error") }
   let(:failure) { Fear.failure(exception) }
 
   it_behaves_like Fear::RightBiased::Left do
     let(:left) { failure }
   end
 
-  describe '#exception' do
+  describe "#exception" do
     subject { failure.exception }
     it { is_expected.to eq(exception) }
   end
 
-  describe '#success?' do
+  describe "#success?" do
     subject { failure }
     it { is_expected.not_to be_success }
   end
 
-  describe '#failure?' do
+  describe "#failure?" do
     subject { failure }
     it { is_expected.to be_failure }
   end
 
-  describe '#get' do
+  describe "#get" do
     subject { proc { failure.get } }
-    it { is_expected.to raise_error(RuntimeError, 'error') }
+    it { is_expected.to raise_error(RuntimeError, "error") }
   end
 
-  describe '#or_else' do
-    context 'default does not fail' do
-      subject { failure.or_else { Fear::Success.new('value') } }
-      it { is_expected.to eq(Fear::Success.new('value')) }
+  describe "#or_else" do
+    context "default does not fail" do
+      subject { failure.or_else { Fear::Success.new("value") } }
+      it { is_expected.to eq(Fear::Success.new("value")) }
     end
 
-    context 'default fails with error' do
-      subject(:or_else) { failure.or_else { raise 'unexpected error' } }
+    context "default fails with error" do
+      subject(:or_else) { failure.or_else { raise "unexpected error" } }
       it { is_expected.to be_kind_of(described_class) }
-      it { expect { or_else.get }.to raise_error(RuntimeError, 'unexpected error') }
+      it { expect { or_else.get }.to raise_error(RuntimeError, "unexpected error") }
     end
   end
 
-  describe '#flatten' do
+  describe "#flatten" do
     subject { failure.flatten }
     it { is_expected.to eq(failure) }
   end
 
-  describe '#select' do
-    subject { failure.select { |v| v == 'value' } }
+  describe "#select" do
+    subject { failure.select { |v| v == "value" } }
     it { is_expected.to eq(failure) }
   end
 
-  context '#recover_with' do
-    context 'block matches the error and does not fail' do
+  context "#recover_with" do
+    context "block matches the error and does not fail" do
       subject do
         failure.recover_with do |m|
           m.case(RuntimeError) { |error| Fear.success(error.message) }
         end
       end
 
-      it 'returns result of evaluation of the block against the error' do
-        is_expected.to eq(Fear::Success.new('error'))
+      it "returns result of evaluation of the block against the error" do
+        is_expected.to eq(Fear::Success.new("error"))
       end
     end
 
-    context 'block does not match the error' do
+    context "block does not match the error" do
       subject do
         failure.recover_with do |m|
           m.case(ZeroDivisionError) { Fear.success(0) }
         end
       end
 
-      it 'returns the same failure' do
+      it "returns the same failure" do
         is_expected.to eq(failure)
       end
     end
 
-    context 'block fails' do
-      subject(:recover_with) { failure.recover_with { raise 'unexpected error' } }
+    context "block fails" do
+      subject(:recover_with) { failure.recover_with { raise "unexpected error" } }
 
       it { is_expected.to be_kind_of(described_class) }
-      it { expect { recover_with.get }.to raise_error(RuntimeError, 'unexpected error') }
+      it { expect { recover_with.get }.to raise_error(RuntimeError, "unexpected error") }
     end
   end
 
-  context '#recover' do
-    context 'block matches the error and does not fail' do
+  context "#recover" do
+    context "block matches the error and does not fail" do
       subject do
         failure.recover do |m|
           m.case(RuntimeError, &:message)
         end
       end
 
-      it 'returns Success of evaluation of the block against the error' do
-        is_expected.to eq(Fear.success('error'))
+      it "returns Success of evaluation of the block against the error" do
+        is_expected.to eq(Fear.success("error"))
       end
     end
 
-    context 'block does not match the error' do
+    context "block does not match the error" do
       subject do
         failure.recover do |m|
           m.case(ZeroDivisionError, &:message)
         end
       end
 
-      it 'returns the same failure' do
+      it "returns the same failure" do
         is_expected.to eq(failure)
       end
     end
 
-    context 'block fails' do
+    context "block fails" do
       subject(:recover) do
         failure.recover do
-          raise 'unexpected error'
+          raise "unexpected error"
         end
       end
 
       it { is_expected.to be_kind_of(described_class) }
-      it { expect { recover.get }.to raise_error(RuntimeError, 'unexpected error') }
+      it { expect { recover.get }.to raise_error(RuntimeError, "unexpected error") }
     end
   end
 
-  describe '#to_either' do
+  describe "#to_either" do
     subject { failure.to_either }
     it { is_expected.to eq(Fear.left(exception)) }
   end
 
-  describe '#===' do
+  describe "#===" do
     subject { match === failure }
 
-    context 'matches erectly' do
+    context "matches erectly" do
       let(:match) { Fear.failure(exception) }
       it { is_expected.to eq(true) }
     end
 
-    context 'value does not match' do
+    context "value does not match" do
       let(:match) { Fear.failure(ArgumentError.new) }
       it { is_expected.to eq(false) }
     end
 
-    context 'matches by class' do
+    context "matches by class" do
       let(:match) { Fear.failure(RuntimeError) }
       it { is_expected.to eq(true) }
     end
 
-    context 'does not matches by class' do
+    context "does not match by class" do
       let(:match) { Fear.failure(ArgumentError) }
       it { is_expected.to eq(false) }
     end
+
+    context "does not match non-try" do
+      let(:match) { Fear.failure(ArgumentError) }
+      let(:failure) { ArgumentError.new }
+
+      it { is_expected.to eq(false) }
+    end
   end
 
-  describe '#match' do
-    context 'matched' do
+  describe "#match" do
+    context "matched" do
       subject do
         failure.match do |m|
           m.failure(->(x) { x.message.length < 2 }) { |x| "Error: #{x}" }
@@ -158,15 +167,15 @@ RSpec.describe Fear::Failure do
         end
       end
 
-      it { is_expected.to eq('Error: error') }
+      it { is_expected.to eq("Error: error") }
     end
 
-    context 'nothing matched and no else given' do
+    context "nothing matched and no else given" do
       subject do
         proc do
           failure.match do |m|
             m.failure(->(x) { x.message.length < 2 }) { |x| "Error: #{x}" }
-            m.success { 'noop' }
+            m.success { "noop" }
           end
         end
       end
@@ -174,7 +183,7 @@ RSpec.describe Fear::Failure do
       it { is_expected.to raise_error(Fear::MatchError) }
     end
 
-    context 'nothing matched and else given' do
+    context "nothing matched and else given" do
       subject do
         failure.match do |m|
           m.failure(->(x) { x.message.length < 2 }) { |x| "Error: #{x}" }
@@ -186,31 +195,9 @@ RSpec.describe Fear::Failure do
     end
   end
 
-  describe '#to_s' do
+  describe "#to_s" do
     subject { failure.to_s }
 
-    it { is_expected.to eq('#<Fear::Failure exception=#<RuntimeError: error>>') }
-  end
-
-  describe 'pattern matching' do
-    subject { Fear.xcase('Failure(v : ArgumentError)') { 'matched' }.call_or_else(var) { 'nothing' } }
-
-    context 'failure of ArgumentError' do
-      let(:var) { Fear.failure(ArgumentError.new) }
-
-      it { is_expected.to eq('matched') }
-    end
-
-    context 'failure of RuntimeError' do
-      let(:var) { Fear.failure(RuntimeError.new) }
-
-      it { is_expected.to eq('nothing') }
-    end
-
-    context 'not failure' do
-      let(:var) { '42' }
-
-      it { is_expected.to eq('nothing') }
-    end
+    it { is_expected.to eq("#<Fear::Failure exception=#<RuntimeError: error>>") }
   end
 end

data/spec/fear/for/mixin_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::For::Mixin do
+  include Fear::For::Mixin
+
+  describe "For()" do
+    subject do
+      For([1, 2], [2, 3], [3, 4]) do |a, b, c|
+        a * b * c
+      end
+    end
+
+    it { is_expected.to eq([6, 8, 9, 12, 12, 16, 18, 24]) }
+  end
+end

data/spec/fear/for_spec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::For do
-  context 'unary' do
-    context 'Some' do
+  context "unary" do
+    context "Some" do
       subject do
         Fear.for(Fear.some(2)) { |a| a * 2 }
       end
@@ -8,7 +10,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.some(4)) }
     end
 
-    context 'None' do
+    context "None" do
       subject do
         Fear.for(Fear.none) { |a| a * 2 }
       end
@@ -17,7 +19,7 @@ RSpec.describe Fear::For do
     end
   end
 
-  context 'arrays' do
+  context "arrays" do
     subject do
       Fear.for([1, 2], [2, 3], [3, 4]) do |a, b, c|
         a * b * c
@@ -27,14 +29,14 @@ RSpec.describe Fear::For do
     it { is_expected.to eq([6, 8, 9, 12, 12, 16, 18, 24]) }
   end
 
-  context 'ternary' do
+  context "ternary" do
     subject do
       Fear.for(first, second, third) do |a, b, c|
         a * b * c
       end
     end
 
-    context 'all Same' do
+    context "all Same" do
       let(:first) { Fear.some(2) }
       let(:second) { Fear.some(3) }
       let(:third) { Fear.some(4) }
@@ -42,7 +44,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.some(24)) }
     end
 
-    context 'first is None' do
+    context "first is None" do
       let(:first) { Fear.none }
       let(:second) { Fear.some(3) }
       let(:third) { Fear.some(4) }
@@ -50,7 +52,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'second is None' do
+    context "second is None" do
       let(:first) { Fear.some(2) }
       let(:second) { Fear.none }
       let(:third) { Fear.some(4) }
@@ -58,7 +60,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'last is None' do
+    context "last is None" do
       let(:first) { Fear.some(2) }
       let(:second) { Fear.some(3) }
       let(:third) { Fear.none }
@@ -66,7 +68,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'all Same in lambdas' do
+    context "all Same in lambdas" do
       let(:first) { proc { Fear.some(2) } }
       let(:second) { proc { Fear.some(3) } }
       let(:third) { proc { Fear.some(4) } }
@@ -74,28 +76,28 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.some(24)) }
     end
 
-    context 'first is None in lambda, second is failure in lambda' do
+    context "first is None in lambda, second is failure in lambda" do
       let(:first) { proc { Fear.none } }
-      let(:second) { proc { raise 'kaboom' } }
+      let(:second) { proc { raise "kaboom" } }
       let(:third) { proc {} }
 
-      it 'returns None without evaluating second and third' do
+      it "returns None without evaluating second and third" do
         is_expected.to eq(Fear.none)
       end
     end
 
-    context 'second is None in lambda, third is failure in lambda' do
+    context "second is None in lambda, third is failure in lambda" do
       let(:first) { Fear.some(2) }
       let(:second) { proc { Fear.none } }
-      let(:third) { proc { raise 'kaboom' } }
+      let(:third) { proc { raise "kaboom" } }
 
-      it 'returns None without evaluating third' do
+      it "returns None without evaluating third" do
         is_expected.to eq(Fear.none)
       end
     end
   end
 
-  context 'refer to previous variable from lambda' do
+  context "refer to previous variable from lambda" do
     subject do
       Fear.for(first, second, third) do |_, b, c|
         b * c