fear 1.2.0 → 2.0.0

data/lib/fear/try.rb

@@ -114,7 +114,7 @@ module Fear
   #   this is a +Failure+.
   #   @return [Option]
   #   @example
-  #     Fear.success(42).to_option                 #=> Fear.some(21)
+  #     Fear.success(42).to_option                 #=> Fear.some(42)
   #     Fear.failure(ArgumentError.new).to_option  #=> Fear.none()
   #
   # @!method any?(&predicate)
@@ -172,7 +172,7 @@ module Fear
   #   @return [Try]
   #   @example
   #     Fear.success(42).select { |v| v > 40 }
-  #       #=> Fear.success(21)
+  #       #=> Fear.success(42)
   #     Fear.success(42).select { |v| v < 40 }
   #       #=> Fear.failure(Fear::NoSuchElementError.new("Predicate does not hold for 42"))
   #     Fear.failure(ArgumentError.new).select { |v| v < 40 }
@@ -317,3 +317,7 @@ module Fear
     end
   end
 end
+
+require "fear/try_pattern_match"
+require "fear/success"
+require "fear/failure"

data/lib/fear/try_api.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fear/try"
+
 module Fear
   module TryApi
     # Constructs a +Try+ using the block. This

data/lib/fear/try_pattern_match.rb

@@ -1,23 +1,19 @@
 # frozen_string_literal: true
 
+require "fear/pattern_match"
+
 module Fear
   # Try pattern matcher
   #
   # @note it has two optimized subclasses +Fear::SuccessPatternMatch+ and +Fear::FailurePatternMatch+
   # @api private
   class TryPatternMatch < Fear::PatternMatch
-    SUCCESS_EXTRACTOR = :get.to_proc
-    private_constant :SUCCESS_EXTRACTOR
-
-    FAILURE_EXTRACTOR = :exception.to_proc
-    private_constant :FAILURE_EXTRACTOR
-
     # Match against +Fear::Success+
     #
     # @param conditions [<#==>]
     # @return [Fear::TryPatternMatch]
     def success(*conditions, &effect)
-      branch = Fear.case(Fear::Success, &SUCCESS_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      branch = Fear.case(Fear::Success, &:get).and_then(Fear.case(*conditions, &effect))
       or_else(branch)
     end
 
@@ -26,8 +22,11 @@ module Fear
     # @param conditions [<#==>]
     # @return [Fear::TryPatternMatch]
     def failure(*conditions, &effect)
-      branch = Fear.case(Fear::Failure, &FAILURE_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      branch = Fear.case(Fear::Failure, &:exception).and_then(Fear.case(*conditions, &effect))
       or_else(branch)
     end
   end
 end
+
+require "fear/success_pattern_match"
+require "fear/failure_pattern_match"

data/lib/fear/utils.rb

@@ -6,9 +6,6 @@ module Fear
     EMPTY_STRING = ""
     public_constant :EMPTY_STRING
 
-    IDENTITY = :itself.to_proc
-    public_constant :IDENTITY
-
     UNDEFINED = Object.new.freeze
     public_constant :UNDEFINED
 

data/lib/fear/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Fear
-  VERSION = "1.2.0"
+  VERSION = "2.0.0"
   public_constant :VERSION
 end

data/lib/fear.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require "fear/utils"
+require "fear/right_biased"
+require "fear/struct"
+require "fear/unit"
 require "fear/either_api"
-require "fear/extractor_api"
 require "fear/for_api"
 require "fear/future_api"
 require "fear/option_api"
@@ -26,57 +29,20 @@ module Fear
   public_constant :PatternSyntaxError
 
   extend EitherApi
-  extend ExtractorApi
   extend ForApi
   extend FutureApi
   extend OptionApi
   extend PatternMatchingApi
   extend TryApi
 
-  autoload :EmptyPartialFunction, "fear/empty_partial_function"
-  autoload :PartialFunction, "fear/partial_function"
-  autoload :PartialFunctionClass, "fear/partial_function_class"
-  autoload :PatternMatch, "fear/pattern_match"
-  autoload :Extractor, "fear/extractor"
-
-  autoload :Unit, "fear/unit"
-  autoload :For, "fear/for"
-  autoload :RightBiased, "fear/right_biased"
-  autoload :Utils, "fear/utils"
-
-  autoload :None, "fear/none"
-  autoload :NoneClass, "fear/none"
-  autoload :NonePatternMatch, "fear/none_pattern_match"
-  autoload :Option, "fear/option"
-  autoload :OptionPatternMatch, "fear/option_pattern_match"
-  autoload :Some, "fear/some"
-  autoload :SomePatternMatch, "fear/some_pattern_match"
-
-  autoload :Failure, "fear/failure"
-  autoload :FailurePatternMatch, "fear/failure_pattern_match"
-  autoload :Success, "fear/success"
-  autoload :SuccessPatternMatch, "fear/success_pattern_match"
-  autoload :Try, "fear/try"
-  autoload :TryPatternMatch, "fear/try_pattern_match"
-
-  autoload :Either, "fear/either"
-  autoload :EitherPatternMatch, "fear/either_pattern_match"
-  autoload :Left, "fear/left"
-  autoload :LeftPatternMatch, "fear/left_pattern_match"
-  autoload :Right, "fear/right"
-  autoload :RightPatternMatch, "fear/right_pattern_match"
-
-  autoload :Await, "fear/await"
-  autoload :Awaitable, "fear/awaitable"
-  autoload :Future, "fear/future"
-  autoload :Promise, "fear/promise"
-
-  autoload :Struct, "fear/struct"
-
   module Mixin
     include Either::Mixin
     include For::Mixin
     include Option::Mixin
     include Try::Mixin
   end
+
+  class << self
+    include Mixin
+  end
 end

data/spec/fear/awaitable_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fear/awaitable"
+
 RSpec.describe Fear::Awaitable do
   subject(:awaitable) { Object.new.extend(Fear::Awaitable) }
 

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

@@ -144,10 +144,17 @@ RSpec.describe Fear::Failure do
       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
@@ -193,26 +200,4 @@ RSpec.describe Fear::Failure do
 
     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
-  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/future_spec.rb

@@ -1,6 +1,18 @@
 # frozen_string_literal: true
 
 RSpec.describe Fear::Future do
+  describe "#initialize" do
+    context "when promise and block are given at the same time" do
+      let(:promise) do
+        Concurrent::Promise.execute { 42 }
+      end
+
+      specify do
+        expect { described_class.new(promise) { 43 } }.to raise_error(ArgumentError, "pass block or promise")
+      end
+    end
+  end
+
   context "#on_complete" do
     it "run callback with value" do
       expect do |callback|
@@ -536,9 +548,11 @@ RSpec.describe Fear::Future do
         it "ensure callbacks are called" do
           expect do |first|
             expect do |second|
-              Fear::Future.successful(5)
+              future = Fear.future { 5 }
                 .and_then { |m| m.success(&first) }
                 .and_then { |m| m.success(&second) }
+
+              Fear::Await.ready(future, 2)
             end.to yield_with_args(5)
           end.to yield_with_args(5)
         end
@@ -591,7 +605,8 @@ RSpec.describe Fear::Future do
         context "first callback is failing" do
           it "calls second callback" do
             expect do |callback|
-              Fear::Future.successful(5).and_then { raise error }.and_then { |m| m.success(&callback) }
+              future = Fear.future { 5 }.and_then { raise error }.and_then { |m| m.success(&callback) }
+              Fear::Await.ready(future, 2)
             end.to yield_with_args(5)
           end
 

data/spec/fear/guard_spec.rb

@@ -77,6 +77,87 @@ RSpec.describe Fear::PartialFunction::Guard do
         expect { guard === 4 }.not_to raise_error
       end
     end
+
+    context "with many arguments" do
+      let(:guard) { Fear::PartialFunction::Guard.and([guard_1, guard_2, guard_3, guard_4]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 6 == 0 } }
+      let(:guard_4) { ->(x) { x % 7 == 0 } }
+      let(:guard_4) { ->(x) { x % 8 == 0 } }
+
+      it { expect(guard === 3360).to eq(true) }
+      it { expect(guard === 10).to eq(false) }
+      it { expect(guard === 8).to eq(false) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 7).to eq(false) }
+      it { expect(guard === 6).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+    end
+
+    describe "#and" do
+      let(:guard) { guard_1_and_guard_2.and(guard_3) }
+      let(:guard_1_and_guard_2) { Fear::PartialFunction::Guard.and([guard_1, guard_2]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 6 == 0 } }
+
+      it { expect(guard === 30).to eq(true) }
+      it { expect(guard === 10).to eq(false) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+      it { expect(guard === 3).to eq(false) }
+    end
+
+    describe "#and", "with three arguments" do
+      let(:guard) { guard_123.and(guard_4) }
+      let(:guard_123) { Fear::PartialFunction::Guard.and([guard_1, guard_2, guard_3]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 6 == 0 } }
+      let(:guard_4) { ->(x) { x % 7 == 0 } }
+
+      it { expect(guard === 420).to eq(true) }
+      it { expect(guard === 10).to eq(false) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 7).to eq(false) }
+      it { expect(guard === 6).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+    end
+
+    describe "#or" do
+      let(:guard) { guard_1_and_guard_2.or(guard_3) }
+      let(:guard_1_and_guard_2) { Fear::PartialFunction::Guard.and([guard_1, guard_2]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 3 == 0 } }
+
+      it { expect(guard === 10).to eq(true) }
+      it { expect(guard === 3).to eq(true) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+      it { expect(guard === 7).to eq(false) }
+    end
+
+    describe "#or", "with three arguments" do
+      let(:guard) { guard_123.or(guard_4) }
+      let(:guard_123) { Fear::PartialFunction::Guard.and([guard_1, guard_2, guard_3]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 6 == 0 } }
+      let(:guard_4) { ->(x) { x % 7 == 0 } }
+
+      it { expect(guard === 30).to eq(true) }
+      it { expect(guard === 7).to eq(true) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+      it { expect(guard === 6).to eq(false) }
+    end
   end
 
   describe ".or" do
@@ -99,5 +180,34 @@ RSpec.describe Fear::PartialFunction::Guard do
 
       it { is_expected.to eq(false) }
     end
+
+    describe "#and" do
+      let(:guard) { guard_1_or_guard_2.and(guard_3) }
+      let(:guard_1_or_guard_2) { Fear::PartialFunction::Guard.or([guard_1, guard_2]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 3 == 0 } }
+
+      it { expect(guard === 6).to eq(true) }
+      it { expect(guard === 15).to eq(true) }
+      it { expect(guard === 5).to eq(false) }
+      it { expect(guard === 2).to eq(false) }
+      it { expect(guard === 3).to eq(false) }
+    end
+
+    describe "#or" do
+      let(:guard) { guard_1_or_guard_2.or(guard_3) }
+      let(:guard_1_or_guard_2) { Fear::PartialFunction::Guard.or([guard_1, guard_2]) }
+
+      let(:guard_1) { ->(x) { x % 5 == 0 } }
+      let(:guard_2) { ->(x) { x % 2 == 0 } }
+      let(:guard_3) { ->(x) { x % 3 == 0 } }
+
+      it { expect(guard === 5).to eq(true) }
+      it { expect(guard === 2).to eq(true) }
+      it { expect(guard === 3).to eq(true) }
+      it { expect(guard === 7).to eq(false) }
+    end
   end
 end

data/spec/fear/left_spec.rb

@@ -140,6 +140,13 @@ RSpec.describe Fear::Left do
       let(:match) { Fear.left(Integer) }
       it { is_expected.to eq(false) }
     end
+
+    context "does non-either" do
+      let(:match) { Fear.left(42) }
+      let(:left) { 42 }
+
+      it { is_expected.to eq(false) }
+    end
   end
 
   describe "#match" do
@@ -185,26 +192,4 @@ RSpec.describe Fear::Left do
 
     it { is_expected.to eq('#<Fear::Left value="value">') }
   end
-
-  describe "pattern matching" do
-    subject { Fear.xcase("Left(v : Integer)") { |v:| "matched #{v}" }.call_or_else(var) { "nothing" } }
-
-    context "left of int" do
-      let(:var) { Fear.left(42) }
-
-      it { is_expected.to eq("matched 42") }
-    end
-
-    context "left of string" do
-      let(:var) { Fear.left("42") }
-
-      it { is_expected.to eq("nothing") }
-    end
-
-    context "not left" do
-      let(:var) { "42" }
-
-      it { is_expected.to eq("nothing") }
-    end
-  end
 end

data/spec/fear/none_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe "Fear::None" do
+RSpec.describe Fear::None do
   it_behaves_like Fear::RightBiased::Left do
     let(:left) { Fear.none }
   end
@@ -31,6 +31,16 @@ RSpec.describe "Fear::None" do
     it { is_expected.to eq(true) }
   end
 
+  describe "#blank?" do
+    subject { none.blank? }
+    it { is_expected.to eq(true) }
+  end
+
+  describe "#present?" do
+    subject { none.present? }
+    it { is_expected.to be_falsey }
+  end
+
   describe "#select" do
     subject { none.select { |value| value > 42 } }
 
@@ -128,20 +138,4 @@ RSpec.describe "Fear::None" do
       it { is_expected.to eq(:default) }
     end
   end
-
-  describe "pattern matching" do
-    subject { Fear.xcase("None()") { "matched" }.call_or_else(var) { "nothing" } }
-
-    context "none" do
-      let(:var) { Fear.none }
-
-      it { is_expected.to eq("matched") }
-    end
-
-    context "not none" do
-      let(:var) { "42" }
-
-      it { is_expected.to eq("nothing") }
-    end
-  end
 end

data/spec/fear/option_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe Fear::Option do
   describe "#zip" do
-    subject { left.zip(right) }
+    subject(:zip) { left.zip(right) }
 
     context "some with some" do
       let(:left) { Fear.some(42) }
@@ -28,6 +28,13 @@ RSpec.describe Fear::Option do
       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) }
@@ -41,6 +48,13 @@ RSpec.describe Fear::Option do
 
       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

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_spec.rb

@@ -2,18 +2,6 @@
 
 RSpec.describe Fear::PartialFunction do
   describe "Fear.case()" do
-    context "condition is extractor" do
-      subject do
-        Fear.xcase("[1, [2, second_of_second, *], 3, *rest]") do |second_of_second:, rest:|
-          [second_of_second, rest]
-        end
-      end
-
-      it { is_expected.to be_defined_at([1, [2, 2, 3, 4], 3, 6, 7]) }
-      it { is_expected.not_to be_defined_at([1, [1, 3, 3, 4], 3, 6, 7]) }
-      it { is_expected.not_to be_defined_at([1, [1, 2, 3, 4], 4, 6, 7]) }
-    end
-
     context "condition as symbol" do
       subject { Fear.case(:even?) { |x| x } }
 
@@ -64,7 +52,7 @@ RSpec.describe Fear::PartialFunction do
   end
 
   describe ".or" do
-    subject { described_class.or(guard_1, guard_2, &Fear::Utils::IDENTITY) }
+    subject { described_class.or(guard_1, guard_2, &:itself) }
 
     let(:guard_1) { ->(x) { x == 42 } }
     let(:guard_2) { ->(x) { x == 21 } }
@@ -75,7 +63,7 @@ RSpec.describe Fear::PartialFunction do
   end
 
   describe ".and" do
-    subject { described_class.and(guard_1, guard_2, &Fear::Utils::IDENTITY) }
+    subject { described_class.and(guard_1, guard_2, &:itself) }
 
     let(:guard_1) { ->(x) { x % 5 == 0 } }
     let(:guard_2) { ->(x) { x % 2 == 0 } }
@@ -130,16 +118,6 @@ RSpec.describe Fear::PartialFunction do
 
       it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 0") }
     end
-
-    context "defined and condition is extractor" do
-      subject { partial_function.([1, 2, 3, 4, 5]) }
-
-      let(:partial_function) do
-        Fear.xcase("[1, second, 3, *rest]") { |second:, rest:| [second, rest] }
-      end
-
-      it { is_expected.to eq([2, [4, 5]]) }
-    end
   end
 
   describe "#to_proc", "#call" do

data/spec/fear/pattern_match_spec.rb

@@ -1,40 +1,6 @@
 # frozen_string_literal: true
 
 RSpec.describe Fear::PatternMatch do
-  context "extracting" do
-    let(:matcher) do
-      described_class.new do |m|
-        m.xcase("Date(year, 2, 29)", ->(year:) { year < 2000 }) do |year:|
-          "#{year} is a leap year before Millennium"
-        end
-        m.xcase("Date(year, 2, 29)") do |year:|
-          "#{year} is a leap year after Millennium"
-        end
-        m.case(Date) do |date|
-          "#{date.year} is not a leap year"
-        end
-      end
-    end
-
-    context "before Millennium" do
-      subject { matcher.(Date.parse("1996-02-29")) }
-
-      it { is_expected.to eq("1996 is a leap year before Millennium") }
-    end
-
-    context "after Millennium" do
-      subject { matcher.(Date.parse("2004-02-29")) }
-
-      it { is_expected.to eq("2004 is a leap year after Millennium") }
-    end
-
-    context "not leap" do
-      subject { matcher.(Date.parse("2003-01-24")) }
-
-      it { is_expected.to eq("2003 is not a leap year") }
-    end
-  end
-
   context "else at the end" do
     let(:matcher) do
       described_class.new do |m|