dry-effects 0.1.0.alpha

data/lib/dry/effects/providers/fork.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+
+module Dry
+  module Effects
+    module Providers
+      class Fork < Provider[:fork]
+        attr_reader :stack
+
+        def fork
+          stack = self.stack.dup
+          -> &cont { Handler.spawn_fiber(stack.dup, &cont) }
+        end
+
+        def call(stack)
+          @stack = stack
+          super
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/providers/implicit.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+
+module Dry
+  module Effects
+    module Providers
+      class Implicit < Provider[:implicit]
+        include Dry::Equalizer(:name, :static, :dictionary)
+
+        param :dependency
+
+        param :static, default: -> { EMPTY_HASH }
+
+        attr_reader :dictionary
+
+        def implicit(arg)
+          dictionary.fetch(arg.class)
+        end
+
+        def call(stack, dynamic = EMPTY_HASH)
+          if dynamic.empty?
+            @dictionary = static
+          else
+            @dictionary = static.merge(dynamic)
+          end
+
+          super(stack)
+        end
+
+        def provide?(effect)
+          super &&
+            dependency.equal?(effect.dependency) &&
+            dictionary.key?(effect.payload[0].class)
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/providers/interrupt.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+require 'dry/effects/instructions/raise'
+require 'dry/effects/halt'
+
+module Dry
+  module Effects
+    module Providers
+      class Interrupt < Provider[:interrupt]
+        param :scope, default: -> { :default }
+
+        def interrupt(*payload)
+          Instructions.Raise(halt.new(payload))
+        end
+
+        def call(_stack)
+          yield
+        rescue halt => e
+          e.payload[0]
+        end
+
+        def halt
+          Halt[scope]
+        end
+
+        def represent
+          "interrupt[#{scope}]"
+        end
+
+        def provide?(effect)
+          super && scope.equal?(effect.scope)
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/providers/lock.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'dry/equalizer'
+require 'dry/effects/provider'
+require 'dry/effects/initializer'
+
+module Dry
+  module Effects
+    module Providers
+      class Lock < Provider[:lock]
+        class Handle
+          include ::Dry::Equalizer(:key)
+
+          extend Initializer
+
+          param :key
+
+          param :meta
+        end
+
+        class Backend
+          extend Initializer
+
+          param :locks, default: -> { ::Hash.new }
+
+          param :mutex, default: -> { ::Mutex.new }
+
+          def lock(key, meta)
+            mutex.synchronize do
+              if locked?(key)
+                nil
+              else
+                locks[key] = Handle.new(key, meta)
+              end
+            end
+          end
+
+          def locked?(key)
+            locks.key?(key)
+          end
+
+          def unlock(handle)
+            mutex.synchronize do
+              if locked?(handle.key)
+                locks.delete(handle.key)
+                true
+              else
+                false
+              end
+            end
+          end
+
+          def meta(key)
+            meta = Undefined.map(locks.fetch(key, Undefined), &:meta)
+            Undefined.default(meta, nil)
+          end
+        end
+
+        Locate = Effect.new(type: :lock, name: :locate)
+
+        option :backend, default: -> { Backend.new }
+
+        def lock(key, meta = Undefined)
+          locked = backend.lock(key, meta)
+          owned << locked if locked
+          locked
+        end
+
+        def locked?(key)
+          backend.locked?(key)
+        end
+
+        def unlock(handle)
+          backend.unlock(handle)
+        end
+
+        def meta(key)
+          backend.meta(key)
+        end
+
+        def locate
+          self
+        end
+
+        def call(stack, backend = Undefined)
+          backend_replace = Undefined.default(backend) do
+            parent = ::Dry::Effects.yield(Locate) { Undefined }
+            Undefined.map(parent, &:backend)
+          end
+
+          with_backend(backend_replace) do
+            super(stack)
+          ensure
+            owned.each { |handle| unlock(handle) }
+          end
+        end
+
+        def with_backend(backend)
+          if Undefined.equal?(backend)
+            yield
+          else
+            begin
+              before, @backend = @backend, backend
+              yield
+            ensure
+              @backend = before
+            end
+          end
+        end
+
+        def owned
+          @owned ||= []
+        end
+
+        def represent
+          if owned.empty?
+            super
+          else
+            "lock[owned=#{owned.size}]"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/providers/parallel.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'concurrent/promise'
+require 'dry/effects/provider'
+
+module Dry
+  module Effects
+    module Providers
+      class Parallel < Provider[:parallel]
+        option :executor, default: -> { :io }
+
+        attr_reader :stack
+
+        def par
+          stack = self.stack.dup
+          proc do |&block|
+            ::Concurrent::Promise.execute(executor: executor) do
+              Handler.spawn_fiber(stack, &block)
+            end
+          end
+        end
+
+        def join(xs)
+          xs.map(&:value!)
+        end
+
+        def call(stack)
+          @stack = stack
+          super
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/providers/random.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+
+module Dry
+  module Effects
+    module Providers
+      class Random < Provider[:random]
+        public :rand
+      end
+    end
+  end
+end

data/lib/dry/effects/providers/reader.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+
+module Dry
+  module Effects
+    module Providers
+      class Reader < Provider[:reader]
+        def self.handle_method(scope, as: Undefined, **)
+          Undefined.default(as) { :"with_#{scope}" }
+        end
+
+        Any = Object.new.tap { |any|
+          def any.===(_)
+            true
+          end
+        }.freeze
+
+        include Dry::Equalizer(:scope, :state)
+
+        attr_reader :state
+
+        param :scope
+
+        option :type, as: :state_type, default: -> { Any }
+
+        def initialize(*)
+          super
+
+          @state = Undefined
+        end
+
+        def read
+          state
+        end
+
+        def call(stack, state)
+          case state
+          when state_type
+            @state = state
+            super(stack)
+          else
+            raise Errors::InvalidValueError.new(state, scope)
+          end
+        end
+
+        def represent
+          if Undefined.equal?(state)
+            "#{type}[#{scope} unset]"
+          else
+            "#{type}[#{scope} set]"
+          end
+        end
+
+        def provide?(effect)
+          effect.type.equal?(:state) && effect.name.equal?(:read) && scope.equal?(effect.scope)
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/providers/resolve.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+require 'dry/effects/instructions/raise'
+
+module Dry
+  module Effects
+    module Providers
+      class Resolve < Provider[:resolve]
+        def self.handle_method(*, as: Undefined, **)
+          Undefined.default(as, :provide)
+        end
+
+        include Dry::Equalizer(:static, :parent, :dynamic)
+
+        Locate = Effect.new(type: :resolve, name: :locate)
+
+        param :static, default: -> { EMPTY_HASH }
+
+        attr_reader :parent
+
+        attr_reader :dynamic
+
+        def initialize(*)
+          super
+          @dynamic = EMPTY_HASH
+        end
+
+        def resolve(key)
+          if parent&.key?(key)
+            parent.resolve(key)
+          elsif dynamic.key?(key)
+            dynamic[key]
+          elsif static.key?(key)
+            static[key]
+          else
+            Instructions.Raise(Errors::ResolutionError.new(key))
+          end
+        end
+
+        def locate
+          self
+        end
+
+        def call(stack, dynamic = EMPTY_HASH, options = EMPTY_HASH)
+          @dynamic = dynamic
+
+          if options.fetch(:overridable, false)
+            @parent = ::Dry::Effects.yield(Locate) { nil }
+          else
+            @parent = nil
+          end
+
+          super(stack)
+        ensure
+          @dynamic = EMPTY_HASH
+        end
+
+        def provide?(effect)
+          if super
+            !effect.name.equal?(:resolve) || key?(effect.payload[0])
+          else
+            false
+          end
+        end
+
+        def key?(key)
+          static.key?(key) || dynamic.key?(key) || parent&.key?(key)
+        end
+
+        def represent
+          containers = [represent_container(static), represent_container(dynamic)].compact.join('+')
+          "resolve[#{containers.empty? ? 'empty' : containers}]"
+        end
+
+        def represent_container(container)
+          if container.is_a?(::Hash)
+            container.empty? ? nil : 'hash'
+          elsif container.is_a?(::Class)
+            container.name || container.to_s
+          else
+            container.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/providers/retry.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+require 'dry/effects/halt'
+
+module Dry
+  module Effects
+    module Providers
+      class Retry < Provider[:retry]
+        include Dry::Equalizer(:scope, :limit, :attempts)
+
+        param :scope
+
+        attr_reader :attempts
+
+        attr_reader :limit
+
+        def call(_, limit)
+          @limit = limit
+          @attempts = 0
+
+          loop do
+            return attempt { yield }
+          rescue halt
+          end
+        end
+
+        def repeat
+          Instructions.Raise(halt.new)
+        end
+
+        def attempt
+          if attempts_exhausted?
+            nil
+          else
+            @attempts += 1
+            yield
+          end
+        end
+
+        def attempts_exhausted?
+          attempts.equal?(limit)
+        end
+
+        def halt
+          Halt[scope]
+        end
+
+        def provide?(effect)
+          super && scope.equal?(effect.scope)
+        end
+
+        def represent
+          "retry[#{scope} #{attempts}/#{limit}]"
+        end
+      end
+    end
+  end
+end