fear 1.0.0 → 2.0.0

data/lib/fear/partial_function/empty.rb

@@ -1,6 +1,12 @@
+# frozen_string_literal: true
+
+require "fear/empty_partial_function"
+
 module Fear
   module PartialFunction
     EMPTY = EmptyPartialFunction.new
     EMPTY.freeze
+
+    public_constant :EMPTY
   end
 end

data/lib/fear/partial_function/guard/and.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module PartialFunction
     class Guard

data/lib/fear/partial_function/guard/and3.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module PartialFunction
     class Guard

data/lib/fear/partial_function/guard/or.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module PartialFunction
     class Guard

data/lib/fear/partial_function/guard.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
+require "fear/partial_function/guard/or"
+require "fear/partial_function/guard/and"
+require "fear/partial_function/guard/and3"
+
 module Fear
   module PartialFunction
     # Guard represents PartialFunction guardian
     #
     # @api private
     class Guard
-      autoload :And, 'fear/partial_function/guard/and'
-      autoload :And3, 'fear/partial_function/guard/and3'
-      autoload :Or, 'fear/partial_function/guard/or'
-
       class << self
         # Optimized version for combination of two guardians
         # Two guarding is a very common situation. For example checking for Some, and checking
@@ -35,7 +37,7 @@ module Fear
           when 0 then Any
           else
             head, *tail = conditions
-            tail.inject(new(head)) { |acc, condition| acc.and(new(condition)) }
+            tail.reduce(new(head)) { |acc, condition| acc.and(new(condition)) }
           end
         end
 
@@ -45,7 +47,7 @@ module Fear
           return Any if conditions.empty?
 
           head, *tail = conditions
-          tail.inject(new(head)) { |acc, condition| acc.or(new(condition)) }
+          tail.reduce(new(head)) { |acc, condition| acc.or(new(condition)) }
         end
       end
 

data/lib/fear/partial_function/lifted.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module PartialFunction
     # @api private

data/lib/fear/partial_function/or_else.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "fear/utils"
+
 module Fear
   module PartialFunction
     # Composite function produced by +PartialFunction#or_else+ method
@@ -36,7 +40,7 @@ module Fear
 
       # @see Fear::PartialFunction#and_then
       def and_then(other = Utils::UNDEFINED, &block)
-        Utils.with_block_or_argument('Fear::PartialFunction::OrElse#and_then', other, block) do |fun|
+        Utils.with_block_or_argument("Fear::PartialFunction::OrElse#and_then", other, block) do |fun|
           OrElse.new(f1.and_then(&fun), f2.and_then(&fun))
         end
       end

data/lib/fear/partial_function.rb

@@ -1,3 +1,14 @@
+# frozen_string_literal: true
+
+require "fear/partial_function/and_then"
+require "fear/partial_function/any"
+require "fear/partial_function/combined"
+require "fear/partial_function/empty"
+require "fear/partial_function/guard"
+require "fear/partial_function/lifted"
+require "fear/partial_function/or_else"
+require "fear/partial_function_class"
+
 module Fear
   # A partial function is a unary function defined on subset of all possible inputs.
   # The method +defined_at?+ allows to test dynamically if an arg is in
@@ -43,14 +54,6 @@ module Fear
   #   @return [#call]
   #   @abstract
   module PartialFunction
-    autoload :AndThen, 'fear/partial_function/and_then'
-    autoload :Any, 'fear/partial_function/any'
-    autoload :Combined, 'fear/partial_function/combined'
-    autoload :EMPTY, 'fear/partial_function/empty'
-    autoload :Guard, 'fear/partial_function/guard'
-    autoload :Lifted, 'fear/partial_function/lifted'
-    autoload :OrElse, 'fear/partial_function/or_else'
-
     # Checks if a value is contained in the function's domain.
     #
     # @param arg [any]
@@ -97,6 +100,12 @@ module Fear
     # @param other [PartialFunction]
     # @return [PartialFunction] a partial function which has as domain the union of the domains
     #   of this partial function and +other+.
+    # @example
+    #   handle_even = Fear.case(:even?.to_proc) { |x| "#{x} is even" }
+    #   handle_odd = Fear.case(:odd?.to_proc) { |x| "#{x} is odd" }
+    #   handle_even_or_odd = handle_even.or_else(odd)
+    #   handle_even_or_odd.(42) #=> 42 is even
+    #   handle_even_or_odd.(42) #=> 21 is odd
     def or_else(other)
       OrElse.new(self, other)
     end
@@ -125,7 +134,7 @@ module Fear
     #   @return [Fear::PartialFunction]
     #
     def and_then(other = Utils::UNDEFINED, &block)
-      Utils.with_block_or_argument('Fear::PartialFunction#and_then', other, block) do |fun|
+      Utils.with_block_or_argument("Fear::PartialFunction#and_then", other, block) do |fun|
         if fun.is_a?(Fear::PartialFunction)
           Combined.new(self, fun)
         else

data/lib/fear/partial_function_class.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # @api private
   class PartialFunctionClass
@@ -25,7 +27,7 @@ module Fear
     # @yield [arg] if function not defined
     def call_or_else(arg)
       if defined_at?(arg)
-        function.call(arg)
+        function.(arg)
       else
         yield arg
       end

data/lib/fear/pattern_match.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # Pattern match builder. Provides DSL for building pattern matcher
   # Pattern match is just a combination of partial functions
@@ -59,7 +61,7 @@ module Fear
 
         Module.new do
           define_method(as) do |&matchers|
-            matcher_class.new(&matchers).call(self)
+            matcher_class.new(&matchers).(self)
           end
         end
       end
@@ -93,16 +95,6 @@ module Fear
       or_else(Fear.case(*guards, &effect))
     end
 
-    # @param pattern [String]
-    # @param guards [<#===>]
-    # @param effect [Proc]
-    # @return [Fear::PartialFunction]
-    # @see #case for details
-    # @see Fear.xcase for details
-    def xcase(pattern, *guards, &effect)
-      or_else(Fear.xcase(pattern, *guards, &effect))
-    end
-
     # @see Fear::PartialFunction#or_else
     def or_else(other)
       self.result = result.or_else(other)

data/lib/fear/pattern_matching_api.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+require "fear/partial_function"
+require "fear/pattern_match"
+
 module Fear
   # @api private
   module PatternMatchingApi
@@ -42,12 +47,6 @@ module Fear
     #     m.case(Integer, :even?.to_proc) { |x| ... }
     #     m.case(Integer, :odd?.to_proc) { |x| ... }
     #
-    # If you want to perform pattern destruction, use +#xcase+ method
-    #
-    #     m.xcase('Date(year, 12, 31)') { |year:| "Last day of the year #{year}" }
-    #
-    # The pattern above ensures that it's 31 of December and extracts year to block named parameter
-    #
     # Since matcher returns +Fear::PartialFunction+, you can combine matchers using
     # partial function API:
     #
@@ -83,7 +82,7 @@ module Fear
     # @yieldparam matcher [Fear::PartialFunction]
     # @return [any]
     def match(value, &block)
-      matcher(&block).call(value)
+      matcher(&block).(value)
     end
 
     # Creates partial function defined on domain described with guards
@@ -109,26 +108,5 @@ module Fear
     def case(*guards, &function)
       PartialFunction.and(*guards, &function)
     end
-
-    # Creates partial function defined on domain described with guard
-    # and perform pattern extraction.
-    #
-    # @param pattern [String] pattern to match against
-    # @param guards [<#===>] other guards against extracted pattern
-    # @yieldparam hash [{Symbol => any}]
-    # @return [Fear::PartialFunction]
-    #
-    # @example
-    #   pf = Fear.xcase('['ok', Some(body)]') { |body:| ...  }
-    #   pf.defined_at?(['ok', Fear.some(body)]) #=> true
-    #   pf.defined_at?(['err', Fear.none]) #=> false
-    #
-    # @example pattern and guards. It matches against non-empty body
-    #
-    #   pf = Fear.xcase('['ok', Some(body)]', ->(body:) { !body.empty? }) { }
-    #
-    def xcase(pattern, *guards, &function)
-      Fear[pattern].and_then(self.case(*guards, &function))
-    end
   end
 end

data/lib/fear/promise.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Fear
   # @api private
   class Promise < Concurrent::IVar
-    # @param options [Hash] options passed to underlying +Concurrent::Future+
-    def initialize(options = {})
+    # @param options [Hash] options passed to underlying +Concurrent::Promise+
+    def initialize(*_, **options)
       super()
       @options = options
       @promise = Concurrent::Promise.new(options) do
@@ -19,7 +21,7 @@ module Fear
 
     # @return [Fear::Future]
     def to_future
-      Future.new(promise, options)
+      Future.new(promise, **options)
     end
 
     # Complete this promise with successful result
@@ -30,7 +32,7 @@ module Fear
       complete(Fear.success(value))
     end
 
-    # Complete this promise with failure
+    # Complete this promise with value
     # @param value [any]
     # @return [self]
     # @raise [IllegalStateException]
@@ -64,7 +66,7 @@ module Fear
       if complete(result)
         self
       else
-        raise IllegalStateException, 'Promise already completed.'
+        raise IllegalStateException, "Promise already completed."
       end
     end
 

data/lib/fear/right.rb

@@ -1,17 +1,11 @@
+# frozen_string_literal: true
+
 module Fear
   class Right
     include Either
     include RightBiased::Right
     include RightPatternMatch.mixin
 
-    EXTRACTOR = proc do |either|
-      if Fear::Right === either
-        Fear.some([either.right_value])
-      else
-        Fear.none
-      end
-    end
-
     # @api private
     def right_value
       value
@@ -65,7 +59,7 @@ module Fear
     # @param reduce_right [Proc]
     # @return [any]
     def reduce(_reduce_left, reduce_right)
-      reduce_right.call(value)
+      reduce_right.(value)
     end
 
     # @return [Either]

data/lib/fear/right_biased.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # @private
   module RightBiased
@@ -7,14 +9,14 @@ module Fear
       # Returns the value from this `RightBiased::Right` or the given argument if
       # this is a `RightBiased::Left`.
       def get_or_else(*args, &block)
-        Utils.assert_arg_or_block!('get_or_else', *args, &block)
+        Utils.assert_arg_or_block!("get_or_else", *args, &block)
         super
       end
 
       # Returns this `RightBiased::Right` or the given alternative if
       # this is a `RightBiased::Left`.
       def or_else(*args, &block)
-        Utils.assert_arg_or_block!('or_else', *args, &block)
+        Utils.assert_arg_or_block!("or_else", *args, &block)
         super.tap do |result|
           Utils.assert_type!(result, left_class, right_class)
         end
@@ -109,7 +111,7 @@ module Fear
 
     module Left
       prepend Interface
-      include Utils
+
       # @!method get_or_else(default)
       #   @param default [any]
       #   @return [any] default value

data/lib/fear/right_pattern_match.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "fear/either_pattern_match"
+
 module Fear
   # @api private
   class RightPatternMatch < EitherPatternMatch

data/lib/fear/some.rb

@@ -1,17 +1,11 @@
+# frozen_string_literal: true
+
 module Fear
   class Some
     include Option
     include RightBiased::Right
     include SomePatternMatch.mixin
 
-    EXTRACTOR = proc do |option|
-      if Fear::Some === option
-        Fear.some([option.get])
-      else
-        Fear.none
-      end
-    end
-
     attr_reader :value
     protected :value
 
@@ -34,6 +28,13 @@ module Fear
       false
     end
 
+    alias :blank? :empty?
+
+    # @return [true]
+    def present?
+      true
+    end
+
     # @return [Option]
     def select
       if yield(value)
@@ -65,5 +66,31 @@ module Fear
 
     # @return [String]
     alias to_s inspect
+
+    # @param other [Fear::Option]
+    # @return [Fear::Option]
+    def zip(other)
+      if other.is_a?(Option)
+        other.map do |x|
+          if block_given?
+            yield(value, x)
+          else
+            [value, x]
+          end
+        end
+      else
+        raise TypeError, "can't zip with #{other.class}"
+      end
+    end
+
+    # @return [RightBiased::Left, RightBiased::Right]
+    def filter_map(&filter)
+      map(&filter).select(&:itself)
+    end
+
+    # @return [Array<any>]
+    def deconstruct
+      [get]
+    end
   end
 end

data/lib/fear/some_pattern_match.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # @api private
   class SomePatternMatch < OptionPatternMatch

data/lib/fear/struct.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "fear/pattern_match"
+
+module Fear
+  # Structs are like regular classes and good for modeling immutable data.
+  #
+  # A minimal struct requires just a list of attributes:
+  #
+  #     User = Fear::Struct.with_attributes(:id, :email, :admin)
+  #     john = User.new(id: 2, email: 'john@example.com', admin: false)
+  #
+  #     john.email #=> 'john@example.com'
+  #
+  # Instead of `.with_attributes` factory method you can use classic inheritance:
+  #
+  #     class User < Fear::Struct
+  #       attribute :id
+  #       attribute :email
+  #       attribute :admin
+  #     end
+  #
+  # Since structs are immutable, you are not allowed to reassign their attributes
+  #
+  #     john.email = ''john.doe@example.com'' #=> raises NoMethodError
+  #
+  # Two structs of the same type with the same attributes are equal
+  #
+  #     john1 = User.new(id: 2, email: 'john@example.com', admin: false)
+  #     john2 = User.new(id: 2, admin: false, email: 'john@example.com')
+  #     john1 == john2 #=> true
+  #
+  # You can create a shallow copy of a +Struct+ by using copy method optionally changing its attributes.
+  #
+  #     john = User.new(id: 2, email: 'john@example.com', admin: false)
+  #     admin_john = john.copy(admin: true)
+  #
+  #     john.admin #=> false
+  #     admin_john.admin #=> true
+  #
+  class Struct
+    include PatternMatch.mixin
+
+    @attributes = [].freeze
+
+    class << self
+      # @param base [Fear::Struct]
+      # @api private
+      def inherited(base)
+        base.instance_variable_set(:@attributes, attributes)
+      end
+
+      # Defines attribute
+      #
+      # @param name [Symbol]
+      # @return [Symbol] attribute name
+      #
+      # @example
+      #   class User < Fear::Struct
+      #     attribute :id
+      #     attribute :email
+      #   end
+      #
+      def attribute(name)
+        name.to_sym.tap do |symbolized_name|
+          @attributes << symbolized_name
+          attr_reader symbolized_name
+        end
+      end
+
+      # Members of this struct
+      #
+      # @return [<Symbol>]
+      def attributes
+        @attributes.dup
+      end
+
+      # Creates new struct with given attributes
+      # @param members [<Symbol>]
+      # @return [Fear::Struct]
+      #
+      # @example
+      #   User = Fear::Struct.with_attributes(:id, :email, :admin) do
+      #     def admin?
+      #       @admin
+      #     end
+      #   end
+      #
+      def with_attributes(*members, &block)
+        members = members
+        block = block
+
+        Class.new(self) do
+          members.each { |member| attribute(member) }
+          class_eval(&block) if block
+        end
+      end
+    end
+
+    # @param attributes [{Symbol => any}]
+    def initialize(**attributes)
+      _check_missing_attributes!(attributes)
+      _check_unknown_attributes!(attributes)
+
+      @values = members.each_with_object([]) do |name, values|
+        attributes.fetch(name).tap do |value|
+          _set_attribute(name, value)
+          values << value
+        end
+      end
+    end
+
+    # Creates a shallow copy of this struct optionally changing the attributes arguments.
+    # @param attributes [{Symbol => any}]
+    #
+    # @example
+    #   User = Fear::Struct.new(:id, :email, :admin)
+    #   john = User.new(id: 2, email: 'john@example.com', admin: false)
+    #   john.admin #=> false
+    #   admin_john = john.copy(admin: true)
+    #   admin_john.admin #=> true
+    #
+    def copy(**attributes)
+      self.class.new(**to_h.merge(attributes))
+    end
+
+    # Returns the struct attributes as an array of symbols
+    # @return [<Symbol>]
+    #
+    # @example
+    #   User = Fear::Struct.new(:id, :email, :admin)
+    #   john = User.new(email: 'john@example.com', admin: false, id: 2)
+    #   john.attributes #=> [:id, :email, :admin]
+    #
+    def members
+      self.class.attributes
+    end
+
+    # Returns the values for this struct as an Array.
+    # @return [Array]
+    #
+    # @example
+    #   User = Fear::Struct.new(:id, :email, :admin)
+    #   john = User.new(email: 'john@example.com', admin: false, id: 2)
+    #   john.to_a #=> [2, 'john@example.com', false]
+    #
+    def to_a
+      @values.dup
+    end
+
+    # @overload to_h()
+    #   Returns a Hash containing the names and values for the struct's attributes
+    #   @return [{Symbol => any}]
+    #
+    # @overload to_h(&block)
+    #   Applies block to pairs of name name and value and use them to construct hash
+    #   @yieldparam pair [<Symbol, any>] yields pair of name name and value
+    #   @return [{Symbol => any}]
+    #
+    # @example
+    #   User = Fear::Struct.new(:id, :email, :admin)
+    #   john = User.new(email: 'john@example.com', admin: false, id: 2)
+    #   john.to_h #=> {id: 2, email: 'john@example.com', admin: false}
+    #   john.to_h do |key, value|
+    #     [key.to_s, value]
+    #   end #=> {'id' => 2, 'email' => 'john@example.com', 'admin' => false}
+    #
+    def to_h(&block)
+      pairs = members.zip(@values)
+      if block_given?
+        Hash[pairs.map(&block)]
+      else
+        Hash[pairs]
+      end
+    end
+
+    # @param other [any]
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(other.class) && to_h == other.to_h
+    end
+
+    INSPECT_TEMPLATE = "<#Fear::Struct %{class_name} %{attributes}>"
+    private_constant :INSPECT_TEMPLATE
+
+    # @return [String]
+    #
+    # @example
+    #   User = Fear::Struct.with_attributes(:id, :email)
+    #   user = User.new(id: 2, email: 'john@exmaple.com')
+    #   user.inspect #=> "<#Fear::Struct User id=2, email=>'john@exmaple.com'>"
+    #
+    def inspect
+      attributes = to_h.map { |key, value| "#{key}=#{value.inspect}" }.join(", ")
+
+      format(INSPECT_TEMPLATE, class_name: self.class.name, attributes: attributes)
+    end
+    alias to_s inspect
+
+    MISSING_KEYWORDS_ERROR = "missing keywords: %{keywords}"
+    private_constant :MISSING_KEYWORDS_ERROR
+
+    private def _check_missing_attributes!(provided_attributes)
+      missing_attributes = members - provided_attributes.keys
+
+      unless missing_attributes.empty?
+        raise ArgumentError, format(MISSING_KEYWORDS_ERROR, keywords: missing_attributes.join(", "))
+      end
+    end
+
+    UNKNOWN_KEYWORDS_ERROR = "unknown keywords: %{keywords}"
+    private_constant :UNKNOWN_KEYWORDS_ERROR
+
+    private def _check_unknown_attributes!(provided_attributes)
+      unknown_attributes = provided_attributes.keys - members
+
+      unless unknown_attributes.empty?
+        raise ArgumentError, format(UNKNOWN_KEYWORDS_ERROR, keywords: unknown_attributes.join(", "))
+      end
+    end
+
+    # @return [void]
+    private def _set_attribute(name, value)
+      instance_variable_set(:"@#{name}", value)
+    end
+
+    # @param keys [Hash, nil]
+    # @return [Hash]
+    def deconstruct_keys(keys)
+      if keys
+        to_h.slice(*(self.class.attributes & keys))
+      else
+        to_h
+      end
+    end
+  end
+end