dry-effects 0.1.0.alpha

data/lib/dry/effects/instruction.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dry
+  module Effects
+    class Instruction
+    end
+  end
+end

data/lib/dry/effects/instructions/execute.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'dry/effects/instruction'
+
+module Dry
+  module Effects
+    module Instructions
+      class Execute < Instruction
+        attr_reader :block
+
+        def initialize(block)
+          @block = block
+        end
+
+        def call
+          block.call
+        end
+      end
+
+      def self.Execute(&block)
+        Execute.new(block)
+      end
+    end
+  end
+end

data/lib/dry/effects/instructions/raise.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'dry/effects/instruction'
+
+module Dry
+  module Effects
+    module Instructions
+      class Raise < Instruction
+        attr_reader :error
+
+        def initialize(error)
+          @error = error
+        end
+
+        def call
+          raise error
+        end
+      end
+
+      def self.Raise(error)
+        Raise.new(error)
+      end
+    end
+  end
+end

data/lib/dry/effects/provider.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'dry/effects/initializer'
+require 'dry/effects/provider/class_interface'
+
+module Dry
+  module Effects
+    class Provider
+      extend Initializer
+      extend ClassInterface
+
+      def call(_stack)
+        yield
+      end
+
+      def represent
+        type.to_s
+      end
+
+      def type
+        self.class.type
+      end
+
+      def provide?(effect)
+        type.equal?(effect.type)
+      end
+    end
+  end
+end

data/lib/dry/effects/provider/class_interface.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'dry/core/class_attributes'
+
+module Dry
+  module Effects
+    class Provider
+      module ClassInterface
+        def self.extended(base)
+          base.instance_exec do
+            defines :type
+
+            @mutex = ::Mutex.new
+            @effects = ::Hash.new do |es, type|
+              @mutex.synchronize do
+                es.fetch(type) do
+                  es[type] = Class.new(Provider).tap do |provider|
+                    provider.type type
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        include Core::ClassAttributes
+
+        attr_reader :effects
+
+        def [](type)
+          if self < Provider
+            Provider.effects.fetch(type) do
+              Provider.effects[type] = Class.new(self).tap do |subclass|
+                subclass.type type
+              end
+            end
+          else
+            @effects[type]
+          end
+        end
+
+        def mixin(*args, **kwargs)
+          handle_method = handle_method(*args, **kwargs)
+
+          provider = new(*args, **kwargs).freeze
+          handler = Handler.new(provider)
+
+          ::Module.new do
+            define_method(handle_method) do |*args, &block|
+              handler.(args, &block)
+            end
+          end
+        end
+
+        def handle_method(*, as: Undefined, **)
+          Undefined.default(as) { :"with_#{type}" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+
+module Dry
+  module Effects
+    module Providers
+      class Amb < Provider[:amb]
+        include Dry::Equalizer(:id, :value)
+
+        attr_reader :value
+
+        param :id
+
+        def get
+          value
+        end
+
+        def call(_)
+          @value = false
+          first = yield
+          @value = true
+          [first, yield]
+        end
+
+        def provide?(effect)
+          super && id.equal?(effect.id)
+        end
+
+        def represent
+          "amb[#{id}=#{@value}]"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+
+module Dry
+  module Effects
+    module Providers
+      class Async < Provider[:async]
+        option :tasks, default: -> { ::Hash.new }
+
+        include Dry::Equalizer(:tasks)
+
+        attr_reader :stack
+
+        def async(block)
+          @tasks[block] = block
+        end
+
+        def await(task)
+          Handler.spawn_fiber(stack, &@tasks.delete(task))
+        end
+
+        def call(stack)
+          @stack = stack
+          super
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+require 'dry/effects/instructions/execute'
+
+module Dry
+  module Effects
+    module Providers
+      class Cache < Provider[:cache]
+        include Dry::Equalizer(:scope, :cache)
+
+        param :scope
+
+        attr_reader :cache
+
+        def fetch_or_store(key, block)
+          if cache.key?(key)
+            cache[key]
+          else
+            Instructions.Execute { cache[key] = block.call }
+          end
+        end
+
+        def call(stack, cache = EMPTY_HASH.dup)
+          @cache = cache
+          super(stack)
+        end
+
+        def provide?(effect)
+          super && scope.eql?(effect.scope)
+        end
+
+        def represent
+          if cache.empty?
+            "cache[#{scope} empty]"
+          else
+            "cache[#{scope} size=#{cache.size}]"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+
+module Dry
+  module Effects
+    module Providers
+      class CurrentTime < Provider[:current_time]
+        include Dry::Equalizer(:fixed, :round)
+
+        option :fixed, default: -> { true }
+
+        option :round, default: -> { Undefined }
+
+        alias_method :fixed?, :fixed
+
+        attr_reader :time
+
+        def call(stack, time = Undefined)
+          if fixed?
+            @time = Undefined.default(time) { ::Time.now }
+          else
+            @time = time
+          end
+          super(stack)
+        end
+
+        def current_time(round_to: Undefined)
+          t = fixed? ? time : Undefined.default(time) { ::Time.now }
+          round = Undefined.default(round_to) { self.round }
+
+          if Undefined.equal?(round)
+            t
+          else
+            t.round(round)
+          end
+        end
+
+        def represent
+          if fixed?
+            "current_time[fixed=#{time.iso8601(6)}]"
+          else
+            'current_time[fixed=false]'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'concurrent/promise'
+require 'dry/effects/provider'
+
+module Dry
+  module Effects
+    module Providers
+      class Defer < Provider[:defer]
+        include Dry::Equalizer(:executor)
+
+        option :executor, default: -> { :io }
+
+        attr_reader :later_calls
+
+        attr_reader :stack
+
+        def defer(block, executor)
+          stack = self.stack.dup
+          at = Undefined.default(executor, self.executor)
+          ::Concurrent::Promise.execute(executor: at) do
+            Handler.spawn_fiber(stack, &block)
+          end
+        end
+
+        def later(block, executor)
+          if @later_calls.frozen?
+            Instructions.Raise(Errors::EffectRejectedError.new(<<~MSG))
+              .later calls are not allowed, they would processed
+              by another stack. Add another defer handler to the current stack
+            MSG
+          else
+            at = Undefined.default(executor, self.executor)
+            stack = self.stack.dup
+            @later_calls << ::Concurrent::Promise.new(executor: at) do
+              Handler.spawn_fiber(stack, &block)
+            end
+            nil
+          end
+        end
+
+        def wait(promises)
+          if promises.is_a?(::Array)
+            ::Concurrent::Promise.zip(*promises).value!
+          else
+            promises.value!
+          end
+        end
+
+        def call(stack, executor: Undefined)
+          unless Undefined.equal?(executor)
+            @executor = executor
+          end
+
+          @stack = stack
+          @later_calls = []
+          super(stack)
+        ensure
+          later_calls.each(&:execute)
+        end
+
+        def dup
+          if defined? @later_calls
+            super.tap { |p| p.instance_exec { @later_calls = EMPTY_ARRAY } }
+          else
+            super
+          end
+        end
+
+        def represent
+          info = []
+          info << executor.to_s if executor.is_a?(::Symbol)
+          info << "call_later=#{later_calls.size}" if later_calls.any?
+
+          if info.empty?
+            'defer'
+          else
+            "defer[#{info.join(' ')}]"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+require 'dry/effects/instructions/raise'
+
+module Dry
+  module Effects
+    module Providers
+      class Env < Provider[:env]
+        include Dry::Equalizer(:values, :dynamic)
+
+        Locate = Effect.new(type: :env, name: :locate)
+
+        param :values, default: -> { EMPTY_HASH }
+
+        attr_reader :parent
+
+        def read(key)
+          parent.fetch(key) { fetch(key) }
+        end
+
+        def fetch(key)
+          values.fetch(key) do
+            if key.is_a?(::String) && ::ENV.key?(key)
+              ::ENV[key]
+            else
+              yield
+            end
+          end
+        end
+        protected :fetch
+
+        def locate
+          self
+        end
+
+        def call(stack, values = EMPTY_HASH, options = EMPTY_HASH)
+          unless values.empty?
+            @values = @values.merge(values)
+          end
+
+          if options.fetch(:overridable, false)
+            @parent = ::Dry::Effects.yield(Locate) { EMPTY_HASH }
+          else
+            @parent = EMPTY_HASH
+          end
+
+          super(stack)
+        end
+
+        def provide?(effect)
+          if super
+            !effect.name.equal?(:read) || key?(effect.payload[0])
+          else
+            false
+          end
+        end
+
+        def key?(key)
+          values.key?(key) || key.is_a?(::String) && ::ENV.key?(key) || parent.key?(key)
+        end
+      end
+    end
+  end
+end