fear 1.0.0 → 2.0.0

data/lib/dry/types/fear/option.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    class Option
+      include Type
+      include ::Dry::Equalizer(:type, :options, inspect: false, immutable: true)
+      include Decorator
+      include Builder
+      include Printable
+
+      # @param [Fear::Option, Object] input
+      #
+      # @return [Fear::Option]
+      #
+      # @api private
+      def call_unsafe(input = Undefined)
+        case input
+        when ::Fear::Option
+          input
+        when Undefined
+          Fear.none
+        else
+          Fear.option(type.call_unsafe(input))
+        end
+      end
+
+      # @param [Fear::Option, Object] input
+      #
+      # @return [Fear::Option]
+      #
+      # @api private
+      def call_safe(input = Undefined)
+        case input
+        when ::Fear::Option
+          input
+        when Undefined
+          Fear.none
+        else
+          Fear.option(type.call_safe(input) { |output = input| return yield(output) })
+        end
+      end
+
+      # @param [Object] input
+      #
+      # @return [Result::Success]
+      #
+      # @api public
+      def try(input = Undefined)
+        result = type.try(input)
+
+        if result.success?
+          Result::Success.new(Fear.option(result.input))
+        else
+          result
+        end
+      end
+
+      # @return [true]
+      #
+      # @api public
+      def default?
+        true
+      end
+
+      # @param [Object] value
+      #
+      # @see Dry::Types::Builder#default
+      #
+      # @raise [ArgumentError] if nil provided as default value
+      #
+      # @api public
+      def default(value)
+        if value.nil?
+          raise ArgumentError, "nil cannot be used as a default of a maybe type"
+        else
+          super
+        end
+      end
+    end
+
+    module Builder
+      # Turn a type into a maybe type
+      #
+      # @return [Option]
+      #
+      # @api public
+      def option
+        Option.new(Types["nil"] | self)
+      end
+    end
+
+    # @api private
+    class Schema
+      class Key
+        # @api private
+        def option
+          __new__(type.option)
+        end
+      end
+    end
+
+    # @api private
+    class Printer
+      MAPPING[Option] = :visit_option
+
+      # @api private
+      def visit_option(maybe)
+        visit(maybe.type) do |type|
+          yield "Fear::Option<#{type}>"
+        end
+      end
+    end
+
+    # Register non-coercible maybe types
+    NON_NIL.each_key do |name|
+      register("option.strict.#{name}", self[name.to_s].option)
+    end
+
+    # Register coercible maybe types
+    COERCIBLE.each_key do |name|
+      register("option.coercible.#{name}", self["coercible.#{name}"].option)
+    end
+  end
+end

data/lib/dry/types/fear.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "dry/types"
+require "fear"
+
+Dry::Types.register_extension(:fear_option) do
+  require "dry/types/fear/option"
+end

data/lib/fear/await.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Fear
+  # You're strongly discouraged to use this module since it may lead to deadlocks,
+  # and reduced performance. Although, blocking may be useful in some cases (e.g. in tests)
+  #
+  # @see https://stackoverflow.com/questions/38155159/why-doesnt-scalas-future-have-a-get-getmaxduration-method-forcing-us-to
+  module Await
+    # Blocks until +Fear::Awaitable+ reached completed state and returns itself
+    # or raises +TimeoutError+
+    #
+    # @param awaitable [Fear::Awaitable]
+    # @param at_most [Fixnum] timeout in seconds
+    # @return [Fear::Awaitable]
+    # @raise [Timeout::Error]
+    #
+    module_function def ready(awaitable, at_most)
+      awaitable.__ready__(at_most)
+    end
+
+    # Blocks until +Fear::Awaitable+ reached completed state and returns its value
+    # or raises +TimeoutError+
+    #
+    # @param awaitable [Fear::Awaitable]
+    # @param at_most [Fixnum] timeout in seconds
+    # @return [any]
+    # @raise [Timeout::Error]
+    #
+    module_function def result(awaitable, at_most)
+      awaitable.__result__(at_most)
+    end
+  end
+end

data/lib/fear/awaitable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Fear
+  # An object which may eventually be completed and awaited using blocking methods.
+  #
+  # @abstract
+  # @api private
+  # @see Fear::Await
+  module Awaitable
+    # Await +completed+ state of this +Awaitable+
+    #
+    # @param _at_most [Fixnum] maximum timeout in seconds
+    # @return [Fear::Awaitable]
+    # @raise [Timeout::Error]
+    def __ready__(_at_most)
+      raise NotImplementedError
+    end
+
+    # Await and return the result of this +Awaitable+
+    #
+    # @param _at_most [Fixnum] maximum timeout in seconds
+    # @return [any]
+    # @raise [Timeout::Error]
+    def __result__(_at_most)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/fear/either.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # Represents a value of one of two possible types (a disjoint union.)
   # An instance of +Either+ is either an instance of +Left+ or +Right+.
@@ -70,7 +72,7 @@ module Fear
   #   Performs the given block if this is a +Right+.
   #   @yieldparam [any] value
   #   @yieldreturn [void]
-  #   @return [Option] itself
+  #   @return [Fear::Either] itself
   #   @example
   #     Fear.right(17).each do |value|
   #       puts value
@@ -93,8 +95,8 @@ module Fear
   #   Returns the given block applied to the value from this +Right+
   #   or returns this if this is a +Left+.
   #   @yieldparam [any] value
-  #   @yieldreturn [Option]
-  #   @return [Option]
+  #   @yieldreturn [Fear::Either]
+  #   @return [Fear::Either]
   #   @example
   #     Fear.right(42).flat_map { |v| Fear.right(v/2) }         #=> Fear.right(21)
   #     Fear.left('undefined').flat_map { |v| Fear.right(v/2) } #=> Fear.left('undefined')
@@ -104,7 +106,7 @@ module Fear
   #   this is a +Left+.
   #   @return [Option]
   #   @example
-  #     Fear.right(42).to_option          #=> Fear.some(21)
+  #     Fear.right(42).to_option          #=> Fear.some(42)
   #     Fear.left('undefined').to_option  #=> Fear.none()
   #
   # @!method any?(&predicate)
@@ -273,6 +275,11 @@ module Fear
     # @return [String]
     alias to_s inspect
 
+    # @return [<any>]
+    def deconstruct
+      [value]
+    end
+
     class << self
       # Build pattern matcher to be used later, despite off
       # +Either#match+ method, id doesn't apply matcher immanently,
@@ -324,3 +331,7 @@ module Fear
     end
   end
 end
+
+require "fear/either_pattern_match"
+require "fear/left"
+require "fear/right"

data/lib/fear/either_api.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "fear/either"
+
 module Fear
   module EitherApi
     # @param value [any]

data/lib/fear/either_pattern_match.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "fear/pattern_match"
+
 module Fear
   # Either pattern matcher
   #
@@ -22,15 +26,12 @@ module Fear
   # @note it has two optimized subclasses +Fear::LeftPatternMatch+ and +Fear::RightPatternMatch+
   # @api private
   class EitherPatternMatch < Fear::PatternMatch
-    LEFT_EXTRACTOR = :left_value.to_proc
-    RIGHT_EXTRACTOR = :right_value.to_proc
-
     # 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))
+      branch = Fear.case(Fear::Right, &:right_value).and_then(Fear.case(*conditions, &effect))
       or_else(branch)
     end
     alias success right
@@ -40,9 +41,12 @@ module Fear
     # @param conditions [<#==>]
     # @return [Fear::EitherPatternMatch]
     def left(*conditions, &effect)
-      branch = Fear.case(Fear::Left, &LEFT_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      branch = Fear.case(Fear::Left, &:left_value).and_then(Fear.case(*conditions, &effect))
       or_else(branch)
     end
     alias failure left
   end
 end
+
+require "fear/left_pattern_match"
+require "fear/right_pattern_match"

data/lib/fear/empty_partial_function.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # Use singleton version of EmptyPartialFunction -- PartialFunction::EMPTY
   # @api private
@@ -28,7 +30,7 @@ module Fear
     end
 
     def to_s
-      'Empty partial function'
+      "Empty partial function"
     end
   end
 

data/lib/fear/failure.rb

@@ -1,15 +1,10 @@
+# frozen_string_literal: true
+
 module Fear
   class Failure
     include Try
     include RightBiased::Left
     include FailurePatternMatch.mixin
-    EXTRACTOR = proc do |try|
-      if Fear::Failure === try
-        Fear.some([try.exception])
-      else
-        Fear.none
-      end
-    end
 
     # @param [StandardError]
     def initialize(exception)
@@ -101,5 +96,10 @@ module Fear
 
     # @return [String]
     alias to_s inspect
+
+    # @return [<StandardError>]
+    def deconstruct
+      [exception]
+    end
   end
 end

data/lib/fear/failure_pattern_match.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # @api private
   class FailurePatternMatch < Fear::TryPatternMatch
@@ -5,4 +7,6 @@ module Fear
       self
     end
   end
+
+  private_constant :FailurePatternMatch
 end

data/lib/fear/for.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Fear
   # @api private
   # @see Fear.for
   module For
-    module_function # rubocop: disable Style/AccessModifierDeclarations
+    module_function
 
     # @param monads [<Fear::Option, Fear::Either, Fear::Try, Proc>]
     #
@@ -30,7 +32,7 @@ module Fear
 
     private def resolve(monad_or_proc, inner_values)
       if monad_or_proc.respond_to?(:call)
-        monad_or_proc.call(*inner_values)
+        monad_or_proc.(*inner_values)
       else
         monad_or_proc
       end

data/lib/fear/for_api.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "fear/for"
+
 module Fear
   module ForApi
     # Syntactic sugar for composition of  multiple monadic operations. It supports two such
@@ -60,7 +64,7 @@ module Fear
     # @return [{#map, #flat_map}]
     #
     def for(*monads, &block)
-      Fear::For.call(monads, &block)
+      Fear::For.(monads, &block)
     end
   end
 end