ruff 1.4.0 → 2.0.0

data/docs/top-level-namespace.html

@@ -6,15 +6,15 @@
 <title>
   Top Level Namespace
   
-    &mdash; Ruff 1.3.1 Documentation
+    &mdash; Ruff 1.4.0 Documentation
   
 </title>
 
-  <link rel="stylesheet" href="css/style.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/style.css" type="text/css" />
 
-  <link rel="stylesheet" href="css/common.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" />
 
-<script type="text/javascript" charset="utf-8">
+<script type="text/javascript">
   pathId = "";
   relpath = '';
 </script>
@@ -100,9 +100,9 @@
 </div>
 
       <div id="footer">
-  Generated on Wed Oct 30 01:51:52 2019 by
+  Generated on Thu Jan  2 19:46:22 2020 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.9.20 (ruby-2.6.5).
+  0.9.22 (ruby-2.6.5).
 </div>
 
     </div>

data/lib/ruff/effect.rb

@@ -2,7 +2,10 @@
 
 # This class provides an effect instance.
 class Ruff::Effect
-  # Each instance must be unique so they have unique id with UUID
+  # Each instance must be unique so they have unique id with an annonymous class instance.
+  #
+  # The class instance may have subtyping relation.
+  # @see <<
   attr_reader :id
 
   # instaciates an effect setting `id`.
@@ -10,13 +13,39 @@ class Ruff::Effect
   # @example
   #   Log = Effect.new #==> it _might_ be Effect<string, nil>
   def initialize
-    @id = SecureRandom.uuid
-    @id.freeze
+    @id = Class.new.new
+  end
+
+  # instanciates an effect, which has an relation `self <: parent`
+  # from the subtyping of `id` object.
+  #
+  # @param [Effect<Arg, Ret>] parent
+  # @return [Effect<Arg, Ret>] with an relation `it <: parent`
+  #
+  # @example
+  #   Exception = Ruff::Effect.new
+  #   RuntimeException = Ruff::Effect << Exception
+  #
+  #   Ruff::Handler.new
+  #     .on(Exception){
+  #       puts "catch"
+  #     }
+  #     .run {
+  #       RuntimeException.perform
+  #     }
+  #   # ==> prints "catch"
+  def self.<<(parent)
+    inst = new
+    parent_id = parent.instance_variable_get('@id')
+    inst.instance_variable_set('@id', (Class.new parent_id.class).new)
+    inst
   end
 
   # sends an effect ID and its arguments to a nearmost handler.
+  #
   # @param [Arg] a of the object `Effect<Arg, Ret>`
   # @return [Ret] of the object `Effect<Arg, Ret>`
+  #
   # @example
   #   Log.perform "hello"
   def perform(*a)

data/lib/ruff/handler.rb

@@ -2,17 +2,41 @@
 
 # In algebraic effects, handler is an first-class object.
 class Ruff::Handler
-  include Ruff::Throws
-
   # makes a new handler, internally having fresh empty hash.
   #
   # This is a effect-handler store and when handliong it is looked up.
-  # Value handler is set `id` function to by default.
-  #
+  # Value handler is set an identity function to by default.
+
+  class Store
+    # is a private class to manage registered handlers
+    def initialize
+      @handler = {}
+    end
+
+    def []=(r, e)
+      @handler[r.id] = e
+    end
+
+    def [](eff)
+      # get a set {(eff', f) | forall (eff', f) in store. eff <: eff'}
+      fns = @handler.filter do |effky, _fun|
+        eff.id.is_a? effky.class
+      end
+
+      # pick a function with *smallest* effect class
+      return fns.min_by { |effky, _| effky.class }[1] unless fns.empty?
+
+      # if found nothing
+      nil
+    end
+  end
+
+  private_constant :Store
+
   # @example
   #   handler = Handler.new
   def initialize
-    @handlers = {}
+    @handlers = Store.new
     @valh = ->(x) { x }
   end
 
@@ -56,7 +80,10 @@ class Ruff::Handler
     self
   end
 
-  # sets effec handler `&fun` for `eff`
+  # sets or updates effec handler `&fun` for `eff`
+  #
+  # Note that `eff` can be a supertype of an effect to be caught.
+  # @see Effect.<<
   #
   # @param [Effect<Arg, Ret>] eff
   #   the effect instance to be handled
@@ -73,7 +100,7 @@ class Ruff::Handler
   #     k[]
   #   }
   def on(eff, &fun)
-    @handlers[eff.id] = fun
+    @handlers[eff] = fun
 
     self
   end
@@ -107,13 +134,13 @@ class Ruff::Handler
     continue(co).call(nil)
   end
 
-  # is also private method.
+  protected
+
+  # receives `handlers` as new handlers.
   def handlers=(handlers)
     @handlers = handlers.dup
   end
 
-  private
-
   def continue(co)
     ->(*arg) { handle(co, co.resume(*arg)) }
   end
@@ -121,20 +148,20 @@ class Ruff::Handler
   # rubocop:disable Metrics/AbcSize
   def handle(co, r)
     case r
-    when Eff
-      if (effh = @handlers[r.id])
+    when Ruff::Throws::Eff
+      if (effh = @handlers[r])
         effh[continue(co), *r.args]
       else
-        Fiber.yield Resend.new(r, continue(co))
+        Fiber.yield Ruff::Throws::Resend.new(r, continue(co))
       end
-    when Resend then
+    when Ruff::Throws::Resend then
       eff = r.eff
       next_k = rehandles(co, r.k)
 
-      if (effh = @handlers[eff.id])
+      if (effh = @handlers[eff])
         effh.call(next_k, *eff.args)
       else
-        Fiber.yield Resend.new(eff, next_k)
+        Fiber.yield Ruff::Throws::Resend.new(eff, next_k)
       end
     else
       @valh.call(r)
@@ -153,6 +180,4 @@ class Ruff::Handler
         .run { k.call(*args) }
     }
   end
-
-  private :handlers=
 end

data/lib/ruff/standard/async.rb

@@ -89,7 +89,7 @@ module Ruff::Standard::Async
       @eff.await.perform p
     end
 
-    # @method with
+    # @method with(&th)
     # @param [Proc<(), _A!{Async.async, Async.yield, Async.await, e}>] th
     #   is a thunk returning `_A` with te possibility to invoke effects,
     #   including `Async.async` , `Async.yield` and `Async.await` .
@@ -108,8 +108,8 @@ module Ruff::Standard::Async
     # rubocop:disable Metrics/AbcSize
     # rubocop:disable Metrics/BlockLength
     define_method :fork do |pr, th|
-      Ruff.handler
-          .to do |v|
+      h = Ruff::Handler.new
+      h.to do |v|
         pp = pr.get
         l = case pp
             when Waiting then pp.get
@@ -123,16 +123,18 @@ module Ruff::Standard::Async
         pr.set(Done.new(v))
         @q.dequeue
       end
-          .on(@eff.async) do |k, f|
+
+      h.on(@eff.async) do |k, f|
         pr_ = Util::Ref.new(Waiting.new([]))
         @q.enqueue(-> { k[pr_] })
         fork(pr_, f)
       end
-          .on(@eff.yield) do |k|
+      h.on(@eff.yield) do |k|
         @q.enqueue(-> { k[] })
         @q.dequeue.call
       end
-          .on(@eff.await) do |k, ppr|
+
+      h.on(@eff.await) do |k, ppr|
         pp = ppr.get
 
         return case pp
@@ -142,7 +144,8 @@ module Ruff::Standard::Async
                  @q.dequeue.call
                end
       end
-          .run { th[] }
+
+      h.run { th[] }
     end
     # rubocop:enable Metrics/BlockLength
     # rubocop:enable Metrics/AbcSize

data/lib/ruff/standard/current_time.rb

@@ -30,7 +30,7 @@ module Ruff::Standard::CurrentTime
     #   returns `A` , without modification by value handler.
     #   But it still has the possibility to invoke effects(`e`).
     def with(&th)
-        @handler.run(&th)
+      @handler.run(&th)
     end
 
     # You can reimplement the handler using this effect instance.

data/lib/ruff/standard/measure_time.rb

@@ -22,13 +22,13 @@ module Ruff::Standard::MeasureTime
     def initialize
       @eff = Ruff.instance
       @handler = Ruff.handler
-          .on(@eff) do |k, label|
+      @handler.on(@eff) do |k, label|
         t1 = Time.now
         result = k[]
         t2 = Time.now
         result + [{ label: label, time: t2 - t1 }]
       end
-          .to { |x| [x] }
+      @handler.to { |x| [x] }
     end
 
     # is a smart method to invoke the effect operation.

data/lib/ruff/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruff
-  VERSION = '1.4.0'
+  VERSION = '2.0.0'
 end

data/version

@@ -1 +1 @@
-1.4.0
+2.0.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruff
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.0.0
 platform: ruby
 authors:
 - nymphium
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-29 00:00:00.000000000 Z
+date: 2020-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -126,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: ONE-SHOT Algebraic Effects for Ruby!