dry-effects 0.1.0.alpha

data/lib/dry/effects/constructors.rb

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

data/lib/dry/effects/container.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'dry/container'
+
+module Dry
+  module Effects
+    class Container
+      include Dry::Container::Mixin
+    end
+  end
+end

data/lib/dry/effects/effect.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'dry/equalizer'
+require 'dry/effects/initializer'
+
+module Dry
+  module Effects
+    class Effect
+      extend Initializer
+
+      include ::Dry::Equalizer(:type, :name, :payload)
+
+      option :type
+
+      option :name, default: -> { type }
+
+      option :payload, default: -> { EMPTY_ARRAY }
+
+      def payload(*payload)
+        if payload.empty?
+          @payload
+        else
+          with(payload: payload)
+        end
+      end
+      alias_method :call, :payload
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Amb < ::Module
+        class AmbEffect < Effect
+          option :id
+        end
+
+        def initialize(id)
+          get = AmbEffect.new(type: :amb, name: :get, id: id)
+
+          module_eval do
+            define_method(:"#{id}?") { ::Dry::Effects.yield(get) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Async < ::Module
+        Async = Effect.new(type: :async, name: :async)
+
+        Await = Effect.new(type: :async, name: :await)
+
+        def initialize
+          module_eval do
+            define_method(:async) { |&block| ::Dry::Effects.yield(Async.payload(block)) }
+            define_method(:await) { |task| ::Dry::Effects.yield(Await.payload(task)) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Cache < ::Module
+        class CacheEffect < Effect
+          option :scope
+        end
+
+        def initialize(scope, shared: false)
+          if scope.is_a?(::Hash)
+            scope, as = scope.to_a[0]
+          else
+            as = :cache
+          end
+
+          fetch_or_store = CacheEffect.new(
+            type: :cache,
+            name: :fetch_or_store,
+            scope: scope
+          )
+
+          if shared
+            key = method(:shared_cache_key)
+          else
+            key = method(:cache_key)
+          end
+
+          methods = Array(as)
+
+          module_eval do
+            methods.each do |meth|
+              define_method(meth) do |*args, &block|
+                if block
+                  eff = fetch_or_store.(key.(self, args), block)
+                else
+                  eff = fetch_or_store.(key.(self, args, method: meth), -> { super(*args) })
+                end
+
+                ::Dry::Effects.yield(eff)
+              end
+            end
+          end
+        end
+
+        def shared_cache_key(_, args, method: Undefined)
+          if Undefined.equal?(method)
+            args
+          else
+            [method, args]
+          end
+        end
+
+        def cache_key(instance, args, method: Undefined)
+          if Undefined.equal?(method)
+            [instance, args]
+          else
+            [instance, method, args]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class CurrentTime < ::Module
+        CurrentTime = Effect.new(type: :current_time)
+
+        def initialize(round: Undefined)
+          get = CurrentTime.payload(round_to: round)
+
+          module_eval do
+            define_method(:current_time) do |round: Undefined|
+              if Undefined.equal?(round)
+                ::Dry::Effects.yield(get)
+              else
+                ::Dry::Effects.yield(get.payload(round_to: round))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Defer < ::Module
+        Defer = Effect.new(type: :defer, name: :defer)
+        Later = Effect.new(type: :defer, name: :later)
+        Wait = Effect.new(type: :defer, name: :wait)
+
+        def initialize
+          module_eval do
+            define_method(:defer) do |executor: Undefined, &block|
+              ::Dry::Effects.yield(Defer.(block, executor))
+            end
+
+            define_method(:wait) do |promises|
+              ::Dry::Effects.yield(Wait.(promises))
+            end
+
+            define_method(:later) do |executor: Undefined, &block|
+              ::Dry::Effects.yield(Later.(block, executor))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Env < ::Module
+        Read = Effect.new(type: :env, name: :read)
+
+        def initialize(*args, **kwargs)
+          readers = args.zip(args) + kwargs.to_a
+
+          module_eval do
+            if readers.empty?
+              define_method(:env) do |key|
+                ::Dry::Effects.yield(Read.(key))
+              end
+            else
+              readers.each do |reader, key|
+                define_method(reader) do
+                  ::Dry::Effects.yield(Read.(key))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Fork < ::Module
+        Fork = Effect.new(type: :fork)
+
+        def initialize
+          module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def fork
+              yield(::Dry::Effects.yield(Fork))
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Implicit < ::Module
+        class ImplicitEffect < Effect
+          option :dependency
+        end
+
+        def initialize(dependency)
+          lookup = ImplicitEffect.new(type: :implicit, dependency: dependency)
+
+          module_eval do
+            define_method(dependency) do |*args|
+              ::Dry::Effects.yield(lookup.(args[0])).(*args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Interrupt < ::Module
+        class InterruptEffect < Effect
+          option :scope
+        end
+
+        def initialize(scope = :default)
+          interrupt = InterruptEffect.new(type: :interrupt, scope: scope)
+
+          module_eval do
+            define_method(scope) do |payload = Undefined|
+              if Undefined.equal?(payload)
+                ::Dry::Effects.yield(interrupt)
+              else
+                ::Dry::Effects.yield(interrupt.(payload))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Lock < ::Module
+        Lock = Effect.new(type: :lock, name: :lock)
+        Meta = Effect.new(type: :lock, name: :meta)
+        Unlock = Effect.new(type: :lock, name: :unlock)
+        Locked = Effect.new(type: :lock, name: :locked?)
+
+        def initialize
+          module_eval do
+            define_method(:lock) do |key, meta: Undefined, &block|
+              if block
+                begin
+                  handle = ::Dry::Effects.yield(Lock.(key, meta))
+                  block.(!handle.nil?)
+                ensure
+                  ::Dry::Effects.yield(Unlock.(handle)) if handle
+                end
+              else
+                ::Dry::Effects.yield(Lock.(key, meta))
+              end
+            end
+
+            define_method(:unlock) do |key|
+              ::Dry::Effects.yield(Unlock.(key))
+            end
+
+            define_method(:locked?) do |key|
+              ::Dry::Effects.yield(Locked.(key))
+            end
+
+            define_method(:lock_meta) do |key|
+              ::Dry::Effects.yield(Meta.(key))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Parallel < ::Module
+        Par = Effect.new(type: :parallel, name: :par)
+        Join = Effect.new(type: :parallel, name: :join)
+
+        def initialize
+          define_method(:par) { |&block| ::Dry::Effects.yield(Par).(&block) }
+          define_method(:join) { |xs| ::Dry::Effects.yield(Join.(xs)) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Random < ::Module
+        Read = Effect.new(type: :random, name: :rand)
+
+        def initialize
+          module_eval do
+            define_method(:rand) { |n| ::Dry::Effects.yield(Read.(n)) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effects/state'
+
+module Dry
+  module Effects
+    module Effects
+      class Reader < State
+        def initialize(scope, writer: false, **opts)
+          super
+        end
+      end
+    end
+  end
+end