fear 0.9.0 → 1.2.0

data/lib/fear/either_api.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Fear
+  module EitherApi
+    # @param value [any]
+    # @return [Fear::Left]
+    # @example
+    #   Fear.left(42) #=> #<Fear::Left value=42>
+    #
+    def left(value)
+      Fear::Left.new(value)
+    end
+
+    # @param value [any]
+    # @return [Fear::Right]
+    # @example
+    #   Fear.right(42) #=> #<Fear::Right value=42>
+    #
+    def right(value)
+      Fear::Right.new(value)
+    end
+  end
+end

data/lib/fear/either_pattern_match.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Fear
+  # Either pattern matcher
+  #
+  # @example
+  #   pattern_match =
+  #     EitherPatternMatch.new
+  #       .right(Integer, ->(x) { x > 2 }) { |x| x * 2 }
+  #       .right(String) { |x| x.to_i * 2 }
+  #       .left(String) { :err }
+  #       .else { 'error '}
+  #
+  #   pattern_match.call(42) => 'NaN'
+  #
+  #  @example the same matcher may be defined using block syntax
+  #    EitherPatternMatch.new do |m|
+  #      m.right(Integer, ->(x) { x > 2 }) { |x| x * 2 }
+  #      m.right(String) { |x| x.to_i * 2 }
+  #      m.left(String) { :err }
+  #      m.else { 'error '}
+  #    end
+  #
+  # @note it has two optimized subclasses +Fear::LeftPatternMatch+ and +Fear::RightPatternMatch+
+  # @api private
+  class EitherPatternMatch < Fear::PatternMatch
+    LEFT_EXTRACTOR = :left_value.to_proc
+    public_constant :LEFT_EXTRACTOR
+
+    RIGHT_EXTRACTOR = :right_value.to_proc
+    public_constant :RIGHT_EXTRACTOR
+
+    # Match against +Fear::Right+
+    #
+    # @param conditions [<#==>]
+    # @return [Fear::EitherPatternMatch]
+    def right(*conditions, &effect)
+      branch = Fear.case(Fear::Right, &RIGHT_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      or_else(branch)
+    end
+    alias success right
+
+    # Match against +Fear::Left+
+    #
+    # @param conditions [<#==>]
+    # @return [Fear::EitherPatternMatch]
+    def left(*conditions, &effect)
+      branch = Fear.case(Fear::Left, &LEFT_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      or_else(branch)
+    end
+    alias failure left
+  end
+end

data/lib/fear/empty_partial_function.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Fear
+  # Use singleton version of EmptyPartialFunction -- PartialFunction::EMPTY
+  # @api private
+  class EmptyPartialFunction
+    include PartialFunction
+
+    def defined_at?(_)
+      false
+    end
+
+    def call(arg)
+      raise MatchError, "partial function not defined at: #{arg}"
+    end
+
+    alias === call
+    alias [] call
+
+    def call_or_else(arg)
+      yield arg
+    end
+
+    def or_else(other)
+      other
+    end
+
+    def and_then(*)
+      self
+    end
+
+    def to_s
+      "Empty partial function"
+    end
+  end
+
+  private_constant :EmptyPartialFunction
+end

data/lib/fear/extractor.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "treetop"
+require "fear/extractor/grammar"
+Treetop.load File.expand_path("extractor/grammar.treetop", __dir__)
+
+module Fear
+  # @api private
+  module Extractor
+    autoload :Pattern, "fear/extractor/pattern"
+    autoload :Matcher, "fear/extractor/matcher"
+
+    autoload :AnonymousArraySplatMatcher, "fear/extractor/anonymous_array_splat_matcher"
+    autoload :AnyMatcher, "fear/extractor/any_matcher"
+    autoload :ArrayHeadMatcher, "fear/extractor/array_head_matcher"
+    autoload :ArrayMatcher, "fear/extractor/array_matcher"
+    autoload :ArraySplatMatcher, "fear/extractor/array_splat_matcher"
+    autoload :EmptyListMatcher, "fear/extractor/empty_list_matcher"
+    autoload :ExtractorMatcher, "fear/extractor/extractor_matcher"
+    autoload :IdentifierMatcher, "fear/extractor/identifier_matcher"
+    autoload :NamedArraySplatMatcher, "fear/extractor/named_array_splat_matcher"
+    autoload :TypedIdentifierMatcher, "fear/extractor/typed_identifier_matcher"
+    autoload :ValueMatcher, "fear/extractor/value_matcher"
+
+    ExtractorNotFound = Class.new(Error)
+    public_constant :ExtractorNotFound
+
+    @mutex = Mutex.new
+    @registry = PartialFunction::EMPTY
+
+    EXTRACTOR_NOT_FOUND = proc do |klass|
+      raise ExtractorNotFound, "could not find extractor for " + klass.inspect
+    end
+    private_constant :EXTRACTOR_NOT_FOUND
+
+    class << self
+      # @param klass [Class, String]
+      # @api private
+      def find_extractor(klass)
+        @registry.call_or_else(klass, &EXTRACTOR_NOT_FOUND)
+      end
+
+      # Register extractor for given class
+      # @!method register_extractor(*names, extractor)
+      #   @param names [<Class, String>, Class, String] name of a class. You can also pass alias for the name
+      #   @param extractor [Proc<any => Fear::Option>] proc taking any argument and returned Option
+      #     of extracted value('s)
+      #
+      # @example
+      #   register_extractor(Fear::Some, Fear.case(Fear::Some) { |some| some.get }.lift)
+      #
+      #   register_extractor(User, Fear.case(User) { |user|} [user.id, user.email] , )
+      #
+      # @example registering an alias. Alias should be CamelCased string
+      #   register_extractor(Fear::Some, 'Some', Fear.case(Fear::Some) { |some| some.get }.lift)
+      #
+      #   # no you can extract Fear::Some's using Some alias
+      #   m.case(Fear['Some(value : Integer)']) { |value:| value * 2 }
+      #
+      def register_extractor(*args)
+        *keys, extractor = *args
+
+        @mutex.synchronize do
+          keys.uniq.each do |key|
+            @registry = BUILD_EXTRACTOR.(key, extractor).or_else(@registry)
+          end
+        end
+        self
+      end
+
+      BUILD_EXTRACTOR = proc do |key, extractor|
+        Fear.matcher do |m|
+          case key
+          when String
+            m.case(Module, ->(lookup) { lookup.to_s == key }) { extractor }
+            m.case(String, key) { extractor }
+          when Module
+            m.case(Module, ->(lookup) { lookup <= key }) { extractor }
+            m.case(String, key.to_s) { extractor }
+          else
+            m.case(key) { extractor } # may it be useful to register other types of keys? lambda?
+          end
+        end
+      end
+    end
+
+    # Multiple arguments extractor example
+    register_extractor("Date", proc do |other|
+      if other.class.name == "Date"
+        Fear.some([other.year, other.month, other.day])
+      else
+        Fear.none
+      end
+    end)
+    register_extractor(::Struct, Fear.case(::Struct, &:to_a).lift)
+    # No argument boolean extractor example
+    register_extractor("IsEven", proc do |int|
+      if int.is_a?(Integer) && int.even?
+        Fear.some([])
+      else
+        Fear.none
+      end
+    end)
+    # Single argument extractor example
+    register_extractor("Fear::Some", "Some", Some::EXTRACTOR)
+    register_extractor("Fear::None", "None", NoneClass::EXTRACTOR)
+    register_extractor("Fear::Right", "Right", Right::EXTRACTOR)
+    register_extractor("Fear::Left", "Left", Left::EXTRACTOR)
+    register_extractor("Fear::Success", "Success", Success::EXTRACTOR)
+    register_extractor("Fear::Failure", "Failure", Failure::EXTRACTOR)
+  end
+end

data/lib/fear/extractor/anonymous_array_splat_matcher.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Fear
+  module Extractor
+    # Match against array splat, E.g. `[1, 2, *]` or `[1, 2, *_]`
+    #
+    class AnonymousArraySplatMatcher < ArraySplatMatcher
+    end
+  end
+end

data/lib/fear/extractor/any_matcher.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Fear
+  module Extractor
+    # Always match, E.g. `_ : Integer` without capturing variable
+    #
+    class AnyMatcher < Matcher
+      def defined_at?(_other)
+        true
+      end
+
+      def bindings(_)
+        Utils::EMPTY_HASH
+      end
+    end
+  end
+end

data/lib/fear/extractor/array_head_matcher.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Fear
+  module Extractor
+    # Part of recursive array matcher. Match against its head.
+    # @see ArrayMatcher
+    class ArrayHeadMatcher < Matcher
+      # @!attribute matcher
+      #   @return [Matcher]
+      # @!attribute index
+      #   @return [Types::Strict::Integer]
+
+      # @param other [<>]
+      def defined_at?(other)
+        if other.empty?
+          false
+        else
+          matcher.defined_at?(other.first)
+        end
+      end
+
+      # @param other [<>]
+      def bindings(other)
+        if other.empty?
+          super
+        else
+          matcher.bindings(other.first)
+        end
+      end
+
+      def failure_reason(other)
+        matcher.failure_reason(other.first)
+      end
+    end
+  end
+end

data/lib/fear/extractor/array_matcher.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Fear
+  module Extractor
+    # Recursive array matcher. Match against its head and tail
+    #
+    class ArrayMatcher < Matcher
+      # @!attribute head
+      #   @return [ArrayHeadMatcher]
+      # @!attribute tail
+      #   @return [ArrayMatcher | EmptyListMatcher]
+
+      def defined_at?(other)
+        if other.is_a?(Array)
+          head.defined_at?(other) && tail.defined_at?(other.slice(1..-1))
+        end
+      end
+
+      def bindings(other)
+        if head.is_a?(ArraySplatMatcher)
+          head.bindings(other)
+        else
+          head.bindings(other).merge(tail.bindings(other.slice(1..-1)))
+        end
+      end
+
+      def failure_reason(other)
+        if other.is_a?(Array)
+          if head.defined_at?(other)
+            tail.failure_reason(other.slice(1..-1))
+          else
+            head.failure_reason(other)
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/fear/extractor/array_splat_matcher.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Fear
+  module Extractor
+    # @abstract
+    class ArraySplatMatcher < Matcher
+      def defined_at?(_other)
+        true
+      end
+
+      def bindings(_)
+        Utils::EMPTY_HASH
+      end
+    end
+  end
+end

data/lib/fear/extractor/empty_list_matcher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Fear
+  module Extractor
+    # Match only if array is empty
+    #
+    class EmptyListMatcher < Matcher
+      # @!attribute index
+      #   @return [Types::Strict::Integer]
+      #
+      def defined_at?(other)
+        other.empty?
+      end
+
+      def bindings(_)
+        Utils::EMPTY_HASH
+      end
+    end
+  end
+end

data/lib/fear/extractor/extractor_matcher.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Fear
+  module Extractor
+    # Match and extract pattern using registered extractor objects
+    # E.g. +Some(a : Integer)+
+    # @see Extractor.register_extractor
+    class ExtractorMatcher < Matcher
+      # @!attribute name
+      #   @return [Types::Strict::String]
+      # @!attribute arguments_matcher
+      #   @return [ArrayMatcher | EmptyListMatcher]
+      #
+
+      def initialize(*)
+        super
+        @extractor = Extractor.find_extractor(name)
+      end
+      attr_reader :extractor
+      private :extractor
+
+      def defined_at?(other)
+        extractor
+          .(other)
+          .map { |v| arguments_matcher.defined_at?(v) }
+          .get_or_else(false)
+      end
+
+      def call_or_else(arg)
+        extractor.(arg)
+          .map { |v| arguments_matcher.call_or_else(v) { yield arg } }
+          .get_or_else { yield arg }
+      end
+
+      def failure_reason(other)
+        extractor.(other).match do |m|
+          m.some(->(v) { arguments_matcher.defined_at?(v) }) { Fear.none }
+          m.some { |v| arguments_matcher.failure_reason(v) }
+          m.none { super }
+        end
+      end
+    end
+  end
+end

data/lib/fear/extractor/grammar.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Fear
+  module Extractor
+    # This module contains AST nodes for GrammarParser
+    # generated by +treetop+. The sole purpose of them all is to
+    # generate matchers
+    module Grammar
+      class Node < Treetop::Runtime::SyntaxNode
+      end
+
+      class EmptyArray < Node
+        def to_matcher
+          EmptyListMatcher.new(node: self)
+        end
+      end
+
+      class ArrayLiteral < Node
+        def to_matcher
+          elements[1].to_matcher
+        end
+      end
+
+      class NonEmptyArray < Node
+        def to_matcher
+          head, tail = elements
+          ArrayMatcher.new(head: head.to_matcher, tail: tail.to_matcher, node: self)
+        end
+      end
+
+      class ArrayTail < Node
+        def to_matcher
+          elements[1].to_matcher
+        end
+      end
+
+      class ArrayHead < Node
+        def to_matcher
+          ArrayHeadMatcher.new(matcher: elements[1].to_matcher, node: elements[1])
+        end
+      end
+
+      class ArraySplat < Node
+        def to_matcher
+          elements[1].to_matcher
+        end
+      end
+
+      class AnonymousArraySplat < Node
+        def to_matcher
+          AnonymousArraySplatMatcher.new(node: self)
+        end
+      end
+
+      class FloatLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          Float(text_value)
+        end
+      end
+
+      class IntegerLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          Integer(text_value, 10)
+        end
+      end
+
+      class StringLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          elements[1].text_value
+        end
+      end
+
+      require "yaml"
+
+      class DoubleQuotedStringLiteral < StringLiteral
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          YAML.safe_load(%(---\n"#{super}"\n))
+        end
+      end
+
+      class SymbolLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          elements[1].value.to_sym
+        end
+      end
+
+      class TrueLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: true, node: self)
+        end
+      end
+
+      class FalseLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: false, node: self)
+        end
+      end
+
+      class NilLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: nil, node: self)
+        end
+      end
+
+      class AnyIdentifier < Node
+        def to_matcher
+          AnyMatcher.new(node: self)
+        end
+      end
+
+      class Identifier < Node
+        def to_matcher
+          IdentifierMatcher.new(name: value, node: self)
+        end
+
+        def value
+          text_value.to_sym
+        end
+      end
+
+      class NamedArraySplat < Node
+        def to_matcher
+          NamedArraySplatMatcher.new(name: name, node: self)
+        end
+
+        def name
+          text_value[1..-1].to_sym
+        end
+      end
+
+      class TypeLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          Object.const_get(text_value)
+        end
+      end
+
+      class TypedIdentifier < Node
+        def to_matcher
+          identifier, type = elements.values_at(0, 2)
+          type.to_matcher.and(identifier.to_matcher)
+        end
+      end
+
+      class IdentifiedMatcher < Node
+        def to_matcher
+          identifier, matcher = elements.values_at(0, -1)
+          identifier.to_matcher.and(matcher.to_matcher)
+        end
+      end
+
+      class ExtractorLiteral < Node
+        def to_matcher
+          ExtractorMatcher.new(
+            name: extractor_name,
+            arguments_matcher: extractor_arguments,
+            node: self,
+          )
+        end
+
+        private def extractor_name
+          name = elements[0].text_value
+          if Object.const_defined?(name)
+            Object.const_get(name)
+          else
+            name
+          end
+        end
+
+        private def extractor_arguments
+          if elements[2].empty?
+            EmptyListMatcher.new(node: self)
+          else
+            elements[2].to_matcher
+          end
+        end
+      end
+    end
+  end
+end