ruff 1.3.0 → 2.1.0

data/docs/top-level-namespace.html

@@ -6,15 +6,15 @@
 <title>
   Top Level Namespace
   
-    &mdash; Ruff 1.3.0 Documentation
+    &mdash; Ruff 2.1.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 Sun Oct  6 23:09:11 2019 by
+  Generated on Wed Jun 10 21:24:09 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.25 (ruby-2.7.1).
 </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_methods :handlers=
 end

data/lib/ruff/standard.rb

@@ -24,3 +24,4 @@ require 'ruff/standard/measure_time'
 require 'ruff/standard/defer'
 require 'ruff/standard/state'
 require 'ruff/standard/async'
+require 'ruff/standard/delim_ctrl'

data/lib/ruff/standard/async.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-# `Async` provides effects `Async.async`, `Async.yield` and `Async.await`, and the implementation async/await.
+# `Async` provides effects `Async.async`, `Async.yield` and `Async.await`,
+# and the implementation async/await.
 # This implementation is based on the tutorial for Multicore OCaml.
 # @see https://github.com/ocamllabs/ocaml-effects-tutorial/blob/master/sources/solved/async_await.ml
 #
@@ -47,8 +48,8 @@ module Ruff::Standard::Async
     # type 'a promise =
     #   | Waiting of ('a, unit) continuation list
     #   | Done of 'a
-    _Waiting = Util::ADT.create
-    _Done = Util::ADT.create
+    Waiting = Util::ADT.create
+    Done = Util::ADT.create
 
     # makes a new instance.
     def initialize
@@ -88,14 +89,14 @@ 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` .
     # @return [()!{e}]
     #   returns unit but still has the possibility to invoke effects `e` .
     define_method :with do |&th|
-      fork(Util::Ref.new(_Waiting.new([])), th)
+      fork(Util::Ref.new(Waiting.new([])), th)
     end
 
     # You can reimplement the handler using these effect instances
@@ -104,46 +105,50 @@ module Ruff::Standard::Async
 
     private
 
+    # 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
-              pp.get
-            else
-              raise 'impossible'
+            when Waiting then pp.get
+            else raise 'impossible'
             end
 
         l.each do |k|
           @q.enqueue(-> { k[v] })
         end
 
-        pr.set(_Done.new(v))
+        pr.set(Done.new(v))
         @q.dequeue
       end
-          .on(@eff.async) do |k, f|
-        pr_ = Util::Ref.new(_Waiting.new([]))
+
+      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, pr|
-        pp = pr.get
+
+      h.on(@eff.await) do |k, ppr|
+        pp = ppr.get
 
         return case pp
-               when _Done
-                 k[pp.get]
-               when _Waiting
-                 pr.set(_Waiting.new(@q.cons(k)))
+               when Done then k[pp.get]
+               when Waiting
+                 pr.set(Waiting.new(@q.cons(k)))
                  @q.dequeue.call
                end
       end
-          .run { th[] }
+
+      h.run { th[] }
     end
+    # rubocop:enable Metrics/BlockLength
+    # rubocop:enable Metrics/AbcSize
   end
 
   # ---

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/delim_ctrl.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# `DelimCtrl` provides one-shot delimited control operators, `shift` and `reset`.
+# @example
+#   DelimCtrl.reset {
+#     puts "hello"
+#     DelimCtrl.shift { |k|
+#       k.call
+#       puts "!"
+#     }
+#
+#     puts "world"
+#   }
+#   # ==>
+#   #   hello
+#   #   world
+#   #   !
+module Ruff::Standard::DelimCtrl
+  # prompt stack
+  @stack = []
+
+  # delimits a continuation
+  # @param [Proc<(), A>] th
+  #   is a thunk. In this thunk `shift` captures a continuation delimited with the thunk.
+  def reset(&th)
+    eff = Ruff::Effect.new
+    @stack.push eff
+
+    ret = Ruff.handler
+              .on(eff) do |k, f|
+                f.call(k)
+              end
+              .run(&th)
+
+    @stack.pop
+    ret
+  end
+
+  # captures a continuation.
+  # @param [Proc<Proc<C, A>, A/B>] k
+  #  is a continuation.
+  def shift(&k)
+    # fetch nearmost prompt
+    top = @stack.last
+    top.perform(k)
+  end
+
+  module_function :reset, :shift
+end

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.3.0'
+  VERSION = '2.1.0'
 end

data/ruff.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
 
   spec.metadata = {
     'documentation_uri' => 'https://nymphium.github.io/ruff'

data/version

@@ -1 +1 @@
-1.3.0
+2.1.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruff
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.1.0
 platform: ruby
 authors:
 - nymphium
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-06 00:00:00.000000000 Z
+date: 2020-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 description: ONE-SHOT Algebraic Effects for Ruby!
 email:
 - s1311350@gmail.com
@@ -49,20 +49,22 @@ files:
 - ".rubocop.yml"
 - ".solargraph.yml"
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
+- docs/.nojekyll
 - docs/Ruff.html
 - docs/Ruff/Effect.html
 - docs/Ruff/Handler.html
 - docs/Ruff/Standard.html
 - docs/Ruff/Standard/Async.html
 - docs/Ruff/Standard/Async/Instance.html
+- docs/Ruff/Standard/Call1cc.html
 - docs/Ruff/Standard/CurrentTime.html
 - docs/Ruff/Standard/CurrentTime/Instance.html
 - docs/Ruff/Standard/Defer.html
 - docs/Ruff/Standard/Defer/Instance.html
+- docs/Ruff/Standard/DelimCtrl.html
 - docs/Ruff/Standard/MeasureTime.html
 - docs/Ruff/Standard/MeasureTime/Instance.html
 - docs/Ruff/Standard/State.html
@@ -96,6 +98,7 @@ files:
 - lib/ruff/standard/async.rb
 - lib/ruff/standard/current_time.rb
 - lib/ruff/standard/defer.rb
+- lib/ruff/standard/delim_ctrl.rb
 - lib/ruff/standard/measure_time.rb
 - lib/ruff/standard/state.rb
 - lib/ruff/standard/util.rb
@@ -108,7 +111,7 @@ licenses:
 - MIT
 metadata:
   documentation_uri: https://nymphium.github.io/ruff
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -123,8 +126,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.1.3
+signing_key:
 specification_version: 4
 summary: ONE-SHOT Algebraic Effects for Ruby!
 test_files: []