fear 0.10.0 → 0.11.0

data/lib/fear/try_pattern_match.rb

@@ -0,0 +1,28 @@
+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
+    FAILURE_EXTRACTOR = :exception.to_proc
+
+    # 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))
+      or_else(branch)
+    end
+
+    # Match against +Fear::Failure+
+    #
+    # @param conditions [<#==>]
+    # @return [Fear::TryPatternMatch]
+    def failure(*conditions, &effect)
+      branch = Fear.case(Fear::Failure, &FAILURE_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      or_else(branch)
+    end
+  end
+end

data/lib/fear/utils.rb

@@ -1,25 +1,35 @@
 module Fear
   # @private
   module Utils
-    extend self
+    UNDEFINED = Object.new.freeze
 
-    def assert_arg_or_block!(method_name, *args)
-      unless block_given? ^ !args.empty?
-        fail ArgumentError, "##{method_name} accepts either one argument or block"
+    class << self
+      def assert_arg_or_block!(method_name, *args)
+        unless block_given? ^ !args.empty?
+          raise ArgumentError, "##{method_name} accepts either one argument or block"
+        end
       end
-    end
 
-    def assert_type!(value, *types)
-      if types.none? { |type| value.is_a?(type) }
-        fail TypeError, "expected `#{value.inspect}` to be of #{types.join(', ')} class"
+      def with_block_or_argument(method_name, arg = UNDEFINED, block = nil)
+        if block.nil? ^ arg.equal?(UNDEFINED)
+          yield(block || arg)
+        else
+          raise ArgumentError, "#{method_name} accepts either block or partial function"
+        end
+      end
+
+      def assert_type!(value, *types)
+        if types.none? { |type| value.is_a?(type) }
+          raise TypeError, "expected `#{value.inspect}` to be of #{types.join(', ')} class"
+        end
       end
-    end
 
-    def return_or_call_proc(value)
-      if value.respond_to?(:call)
-        value.call
-      else
-        value
+      def return_or_call_proc(value)
+        if value.respond_to?(:call)
+          value.call
+        else
+          value
+        end
       end
     end
   end

data/lib/fear/version.rb

@@ -1,3 +1,3 @@
 module Fear
-  VERSION = '0.10.0'.freeze
+  VERSION = '0.11.0'.freeze
 end

data/lib/fear.rb

@@ -1,27 +1,44 @@
 require 'dry-equalizer'
 require 'fear/version'
+require 'fear/pattern_matching_api'
 
 module Fear
   Error = Class.new(StandardError)
-  IllegalStateException = Class.new(Error)
   NoSuchElementError = Class.new(Error)
+  MatchError = Class.new(Error)
+  extend PatternMatchingApi
+
+  autoload :EmptyPartialFunction, 'fear/empty_partial_function'
+  autoload :PartialFunction, 'fear/partial_function'
+  autoload :PartialFunctionClass, 'fear/partial_function_class'
+  autoload :PatternMatch, 'fear/pattern_match'
 
   autoload :Done, 'fear/done'
   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 :None, 'fear/none'
+  autoload :SomePatternMatch, 'fear/some_pattern_match'
 
-  autoload :Try, 'fear/try'
-  autoload :Success, 'fear/success'
   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'
 
   module Mixin
     include Either::Mixin

data/spec/fear/either_pattern_match_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe Fear::EitherPatternMatch do
+  include Fear::Either::Mixin
+
+  context 'Right' do
+    let(:matcher) do
+      described_class.new do |m|
+        m.right(:even?) { |x| "#{x} is even" }
+        m.right(:odd?) { |x| "#{x} is odd" }
+      end
+    end
+
+    it do
+      expect(matcher.call(Right(4))).to eq('4 is even')
+      expect(matcher.call(Right(3))).to eq('3 is odd')
+      expect do
+        matcher.call(Left(44))
+      end.to raise_error(Fear::MatchError)
+    end
+  end
+
+  context 'Left' do
+    let(:matcher) do
+      described_class.new do |m|
+        m.left(:even?) { |x| "#{x} is even" }
+        m.left(:odd?) { |x| "#{x} is odd" }
+      end
+    end
+
+    it do
+      expect(matcher.call(Left(4))).to eq('4 is even')
+      expect(matcher.call(Left(3))).to eq('3 is odd')
+      expect do
+        matcher.call(Right(44))
+      end.to raise_error(Fear::MatchError)
+    end
+  end
+end

data/spec/fear/failure_spec.rb

@@ -33,7 +33,7 @@ RSpec.describe Fear::Failure do
     end
 
     context 'default fails with error' do
-      subject(:or_else) { failure.or_else { fail 'unexpected error' } }
+      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') }
     end
@@ -63,7 +63,7 @@ RSpec.describe Fear::Failure do
     end
 
     context 'block fails' do
-      subject(:recover_with) { failure.recover_with { fail 'unexpected error' } }
+      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') }
@@ -80,7 +80,7 @@ RSpec.describe Fear::Failure do
     end
 
     context 'block fails' do
-      subject(:recover) { failure.recover { fail 'unexpected error' } }
+      subject(:recover) { failure.recover { raise 'unexpected error' } }
 
       it { is_expected.to be_kind_of(described_class) }
       it { expect { recover.get }.to raise_error(RuntimeError, 'unexpected error') }
@@ -115,4 +115,42 @@ RSpec.describe Fear::Failure do
       it { is_expected.to eq(false) }
     end
   end
+
+  describe '#match' do
+    context 'matched' do
+      subject do
+        failure.match do |m|
+          m.failure(->(x) { x.message.length < 2 }) { |x| "Error: #{x}" }
+          m.failure(->(x) { x.message.length > 2 }) { |x| "Error: #{x}" }
+          m.success(->(x) { x.length > 2 }) { |x| "Success: #{x}" }
+        end
+      end
+
+      it { is_expected.to eq('Error: error') }
+    end
+
+    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' }
+          end
+        end
+      end
+
+      it { is_expected.to raise_error(Fear::MatchError) }
+    end
+
+    context 'nothing matched and else given' do
+      subject do
+        failure.match do |m|
+          m.failure(->(x) { x.message.length < 2 }) { |x| "Error: #{x}" }
+          m.else { :default }
+        end
+      end
+
+      it { is_expected.to eq(:default) }
+    end
+  end
 end

data/spec/fear/for_spec.rb

@@ -2,7 +2,7 @@ RSpec.describe Fear::For do
   context 'unary' do
     context 'Some' do
       subject do
-        For(a: Some(2)) { a * 2 }
+        For(Some(2)) { |a| a * 2 }
       end
 
       it { is_expected.to eq(Some(4)) }
@@ -10,38 +10,26 @@ RSpec.describe Fear::For do
 
     context 'None' do
       subject do
-        For(a: None()) { a * 2 }
+        For(None()) { |a| a * 2 }
       end
 
       it { is_expected.to eq(None()) }
     end
   end
 
-  context 'access method from outer scope' do
-    def two
-      2
-    end
-    private :two
-
-    subject do
-      For(a: Some(2)) { a * two }
-    end
-
-    it { is_expected.to eq(Some(4)) }
-  end
-
   context 'arrays' do
     subject do
-      For(a: [1, 2], b: [2, 3], c: [3, 4]) 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
 
   context 'ternary' do
     subject do
-      For(a: first, b: second, c: third) do
+      For(first, second, third) do |a, b, c|
         a * b * c
       end
     end
@@ -79,17 +67,17 @@ RSpec.describe Fear::For do
     end
 
     context 'all Same in lambdas' do
-      let(:first) { -> { Some(2) } }
-      let(:second) { -> { Some(3) } }
-      let(:third) { -> { Some(4) } }
+      let(:first) { proc { Some(2) } }
+      let(:second) { proc { Some(3) } }
+      let(:third) { proc { Some(4) } }
 
       it { is_expected.to eq(Some(24)) }
     end
 
     context 'first is None in lambda, second is failure in lambda' do
-      let(:first) { -> { None() } }
-      let(:second) { -> { fail 'kaboom' } }
-      let(:third) { -> {} }
+      let(:first) { proc { None() } }
+      let(:second) { proc { raise 'kaboom' } }
+      let(:third) { proc {} }
 
       it 'returns None without evaluating second and third' do
         is_expected.to eq(None())
@@ -98,8 +86,8 @@ RSpec.describe Fear::For do
 
     context 'second is None in lambda, third is failure in lambda' do
       let(:first) { Some(2) }
-      let(:second) { -> { None() } }
-      let(:third) { -> { fail 'kaboom' } }
+      let(:second) { proc { None() } }
+      let(:third) { proc { raise 'kaboom' } }
 
       it 'returns None without evaluating third' do
         is_expected.to eq(None())
@@ -109,15 +97,15 @@ RSpec.describe Fear::For do
 
   context 'refer to previous variable from lambda' do
     subject do
-      For(a: first, b: second, c: third) do
+      For(first, second, third) do |_, b, c|
         b * c
       end
     end
 
     let(:first) { Some(Some(2)) }
-    let(:second) { -> { a } }
-    let(:third) { -> { Some(3) } }
+    let(:second) { ->(a) { a.map { |x| x * 2 } } }
+    let(:third) { proc { Some(3) } }
 
-    it { is_expected.to eq(Some(6)) }
+    it { is_expected.to eq(Some(12)) }
   end
 end

data/spec/fear/guard_spec.rb

@@ -0,0 +1,101 @@
+RSpec.describe Fear::PartialFunction::Guard do
+  context 'Class' do
+    context 'match' do
+      subject { Fear::PartialFunction::Guard.new(Integer) === 4 }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context 'not match' do
+      subject { Fear::PartialFunction::Guard.new(Integer) === '4' }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  context 'Symbol' do
+    context 'match' do
+      subject { Fear::PartialFunction::Guard.new(:even?) === 4 }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context 'not match' do
+      subject { Fear::PartialFunction::Guard.new(:even?) === 3 }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  context 'Proc' do
+    context 'match' do
+      subject { Fear::PartialFunction::Guard.new(->(x) { x.even? }) === 4 }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context 'not match' do
+      subject { Fear::PartialFunction::Guard.new(->(x) { x.even? }) === 3 }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  describe '.and' do
+    context 'match' do
+      subject { guard === 4 }
+      let(:guard) { Fear::PartialFunction::Guard.and([Integer, :even?, ->(x) { x.even? }]) }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context 'not match' do
+      subject { guard === 3 }
+      let(:guard) { Fear::PartialFunction::Guard.and([Integer, :even?, ->(x) { x.even? }]) }
+
+      it { is_expected.to eq(false) }
+    end
+
+    context 'empty array' do
+      subject { guard === 4 }
+      let(:guard) { Fear::PartialFunction::Guard.and([]) }
+
+      it 'matches any values' do
+        is_expected.to eq(true)
+      end
+    end
+
+    context 'short circuit' do
+      let(:guard) { Fear::PartialFunction::Guard.and([first, second, third]) }
+      let(:first) { ->(_) { false } }
+      let(:second) { ->(_) { raise } }
+      let(:third) { ->(_) { raise } }
+
+      it 'does not call the second and the third' do
+        expect { guard === 4 }.not_to raise_error
+      end
+    end
+  end
+
+  describe '.or' do
+    let(:guard) { Fear::PartialFunction::Guard.or(['F', Integer]) }
+
+    context 'match second' do
+      subject { guard === 4 }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context 'match first' do
+      subject { guard === 'F' }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context 'not match' do
+      subject { guard === 'A&' }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+end

data/spec/fear/left_spec.rb

@@ -141,4 +141,42 @@ RSpec.describe Fear::Left do
       it { is_expected.to eq(false) }
     end
   end
+
+  describe '#match' do
+    context 'matched' do
+      subject do
+        left.match do |m|
+          m.left(->(x) { x.length < 2 }) { |x| "Left: #{x}" }
+          m.left(->(x) { x.length > 2 }) { |x| "Left: #{x}" }
+          m.right(->(x) { x.length > 2 }) { |x| "Right: #{x}" }
+        end
+      end
+
+      it { is_expected.to eq('Left: value') }
+    end
+
+    context 'nothing matched and no else given' do
+      subject do
+        proc do
+          left.match do |m|
+            m.left(->(x) { x.length < 2 }) { |x| "Left: #{x}" }
+            m.right { |_| 'noop' }
+          end
+        end
+      end
+
+      it { is_expected.to raise_error(Fear::MatchError) }
+    end
+
+    context 'nothing matched and else given' do
+      subject do
+        left.match do |m|
+          m.left(->(x) { x.length < 2 }) { |x| "Left: #{x}" }
+          m.else { :default }
+        end
+      end
+
+      it { is_expected.to eq(:default) }
+    end
+  end
 end

data/spec/fear/none_spec.rb

@@ -46,4 +46,84 @@ RSpec.describe Fear::None do
       is_expected.to eq(None())
     end
   end
+
+  describe '.new' do
+    subject { Fear::None.class.new }
+
+    it { is_expected.to eq(Fear::None) }
+  end
+
+  describe '.inherited' do
+    subject { -> { Class.new(Fear::None.class) } }
+
+    it { is_expected.to raise_error }
+  end
+
+  describe '#to_s' do
+    subject { none.to_s }
+
+    it { is_expected.to eq('Fear::None') }
+  end
+
+  describe '#inspect' do
+    subject { none.inspect }
+
+    it { is_expected.to eq('Fear::None') }
+  end
+
+  describe '#===' do
+    context 'None' do
+      subject { Fear::None === none }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context 'Fear::Some' do
+      subject { Fear::None === Some(4) }
+
+      it { is_expected.to eq(false) }
+    end
+
+    context 'Integer' do
+      subject { Fear::None === 4 }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  describe '#match' do
+    context 'matched' do
+      subject do
+        none.match do |m|
+          m.some { |x| x * 2 }
+          m.none { 'noop' }
+        end
+      end
+
+      it { is_expected.to eq('noop') }
+    end
+
+    context 'nothing matched and no else given' do
+      subject do
+        proc do
+          none.match do |m|
+            m.some { |x| x * 2 }
+          end
+        end
+      end
+
+      it { is_expected.to raise_error(Fear::MatchError) }
+    end
+
+    context 'nothing matched and else given' do
+      subject do
+        none.match do |m|
+          m.some { |x| x * 2 }
+          m.else { :default }
+        end
+      end
+
+      it { is_expected.to eq(:default) }
+    end
+  end
 end

data/spec/fear/option_pattern_match_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe Fear::OptionPatternMatch do
+  include Fear::Option::Mixin
+
+  context 'Some' do
+    let(:matcher) do
+      described_class.new do |m|
+        m.some(:even?) { |x| "#{x} is even" }
+        m.some(:odd?) { |x| "#{x} is odd" }
+      end
+    end
+
+    it do
+      expect(matcher.call(Some(4))).to eq('4 is even')
+      expect(matcher.call(Some(3))).to eq('3 is odd')
+      expect do
+        matcher.call(None())
+      end.to raise_error(Fear::MatchError)
+    end
+  end
+
+  context 'None' do
+    let(:matcher) do
+      described_class.new do |m|
+        m.none { 'nil' }
+      end
+    end
+
+    it do
+      expect(matcher.call(None())).to eq('nil')
+      expect do
+        matcher.call(Some(3))
+      end.to raise_error(Fear::MatchError)
+    end
+  end
+end

data/spec/fear/partial_function/empty_spec.rb

@@ -0,0 +1,36 @@
+RSpec.describe Fear::PartialFunction::EMPTY 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) } }
+
+    it { is_expected.to raise_error(Fear::MatchError, 'partial function not defined at: 42') }
+  end
+
+  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') }
+  end
+
+  describe '#and_then' do
+    subject { described_class.and_then { |_x| 'then' } }
+
+    it { is_expected.to eq(described_class) }
+  end
+
+  describe '#or_else' do
+    subject { described_class.or_else(other) }
+
+    let(:other) { Fear.case(proc { true }) { 'other' } }
+
+    it { is_expected.to eq(other) }
+  end
+
+  it { is_expected.to be_kind_of(Fear::PartialFunction) }
+end