ruff 1.2.0 → 1.3.0

data/docs/top-level-namespace.html

@@ -6,7 +6,7 @@
 <title>
   Top Level Namespace
   
-    &mdash; Ruff 1.1.0 Documentation
+    &mdash; Ruff 1.3.0 Documentation
   
 </title>
 
@@ -100,7 +100,7 @@
 </div>
 
       <div id="footer">
-  Generated on Fri Oct  4 21:12:21 2019 by
+  Generated on Sun Oct  6 23:09:11 2019 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
   0.9.20 (ruby-2.6.5).
 </div>

data/lib/ruff.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'ruff/version'
-require 'ruff/objects'
-require 'ruff/effect'
-require 'ruff/handler'
-require 'securerandom'
-
 module Ruff
   class << self
+    require 'ruff/version'
+    require 'ruff/objects'
+    require 'ruff/effect'
+    require 'ruff/handler'
+    require 'securerandom'
+
     # is alias for `Effect.new`
     # @see Effect.initialize Effect.initialize
     #

data/lib/ruff/handler.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'securerandom'
-
 # In algebraic effects, handler is an first-class object.
 class Ruff::Handler
   include Ruff::Throws

data/lib/ruff/standard.rb

@@ -23,3 +23,4 @@ require 'ruff/standard/current_time'
 require 'ruff/standard/measure_time'
 require 'ruff/standard/defer'
 require 'ruff/standard/state'
+require 'ruff/standard/async'

data/lib/ruff/standard/async.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+# `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
+#
+# The module has an instance of `Instance` and provides its methods as module method.
+# @see Standard::Async::Instance
+# @example
+#   Async.with do
+#     task = lambda { |name|
+#       lambda {
+#         puts "Starting #{name}"
+#         v = (Random.rand * (10**3)).floor
+#         puts "Yielding #{name}"
+#         Async.yield
+#         puts "Eidnig #{name} with #{v}"
+#
+#         v
+#       }
+#     }
+#
+#     pa = Async.async(task.call('a'))
+#     pb = Async.async(task.call('b'))
+#     pc = Async.async lambda {
+#       Async.await(pa) + Async.await(pb)
+#     }
+#
+#     puts "sum is #{Async.await pc}"
+#   end
+#   #==>
+#   # Starting a
+#   # Yielding a
+#   # Eidnig a with 423
+#   # Starting b
+#   # Yielding b
+#   # Eidnig b with 793
+#   # sum is 1216
+module Ruff::Standard::Async
+  class Instance
+    require 'ostruct'
+    require 'ruff/standard/util'
+
+    # are ADT-like classes which have only getter method.
+    # These are used internally.
+    #
+    # type 'a promise =
+    #   | Waiting of ('a, unit) continuation list
+    #   | Done of 'a
+    _Waiting = Util::ADT.create
+    _Done = Util::ADT.create
+
+    # makes a new instance.
+    def initialize
+      # delegates effect instances.
+      @eff = OpenStruct.new(
+        async: Ruff.instance,
+        yield: Ruff.instance,
+        await: Ruff.instance
+      )
+
+      # is a proc queue.
+      @q = Util::FnStack.new
+    end
+
+    # is a smart method to invoke the effect operation `Async.async` .
+    # @param [Proc<(), A>] th
+    #   is a thunk asynchronously computed.
+    # @return [Promise<A>]
+    #   with `with` , returns `Promise<A>` with running concurrently .
+    def async(th)
+      @eff.async.perform th
+    end
+
+    # is a smart method to invoke the effect operation `Async.yield` .
+    # @return [()]
+    #   with `with` , yields the control to another task.
+    def yield
+      @eff.yield.perform
+    end
+
+    # is a smart method to invoke the effect operation `Async.await` .
+    # @param [Promise<A>] p
+    #   is a promise to run.
+    # @return [A]
+    #   with `with` returns the result of *promise* computation.
+    def await(p)
+      @eff.await.perform p
+    end
+
+    # @method with
+    # @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)
+    end
+
+    # You can reimplement the handler using these effect instances
+    # with accessing `Async.async` , `Async.yield` , and `Async.await` .
+    attr_reader :eff
+
+    private
+
+    define_method :fork do |pr, th|
+      Ruff.handler
+          .to do |v|
+        pp = pr.get
+        l = case pp
+            when _Waiting
+              pp.get
+            else
+              raise 'impossible'
+            end
+
+        l.each do |k|
+          @q.enqueue(-> { k[v] })
+        end
+
+        pr.set(_Done.new(v))
+        @q.dequeue
+      end
+          .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|
+        @q.enqueue(-> { k[] })
+        @q.dequeue.call
+      end
+          .on(@eff.await) do |k, pr|
+        pp = pr.get
+
+        return case pp
+               when _Done
+                 k[pp.get]
+               when _Waiting
+                 pr.set(_Waiting.new(@q.cons(k)))
+                 @q.dequeue.call
+               end
+      end
+          .run { th[] }
+    end
+  end
+
+  # ---
+  @inst = Instance.new
+  @eff = @inst.eff
+
+  # @see Instance#async
+  def async(asynth)
+    @inst.async asynth
+  end
+
+  # @see Instance#await
+  def await(p)
+    @inst.await p
+  end
+
+  # @see Instance#yield
+  def yield
+    @inst.yield
+  end
+
+  # @see Instance#with
+  def with(&th)
+    @inst.with(&th)
+  end
+
+  module_function :async, :await, :yield, :with
+
+  # @see Instance#eff
+  attr_reader :eff
+end

data/lib/ruff/standard/state.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'ostruct'
-
 # `State` provides effects `State.get` and `State.modify` ,
 # and the implementation of the mutable cell or so-called *state* .
 #
@@ -16,22 +14,24 @@ require 'ostruct'
 #       puts s #==> 30
 #       0
 #     }
-#  
+#
 #     puts State.get #==> 0
-#  
+#
 #     State.put 11
 #   }
-#  
+#
 #   puts r #==> 11
 module Ruff::Standard::State
   class Instance
+    require 'ostruct'
+
     # makes new instances.
     def initialize
-      get = Ruff.instance
-      modify = Ruff.instance
-
-      # delegates effect instances
-      @eff = OpenStruct.new(get: get, modify: modify)
+      # delegates effect instances.
+      @eff = OpenStruct.new(
+        get: Ruff.instance,
+        modify: Ruff.instance
+      )
     end
 
     # is a smart method to invoke the effect operation `State.get` .
@@ -105,33 +105,33 @@ module Ruff::Standard::State
   @inst = Instance.new
   @eff = @inst.eff
 
-  # @see Ruff::Standard::State::Instance#get
+  # @see Instance#get
   def get
     @inst.get
   end
 
-  # @see Ruff::Standard::State::Instance#modify
+  # @see Instance#modify
   def modify(&fn)
     @inst.modify(&fn)
   end
 
-  # @see Ruff::Standard::State::Instance#put
+  # @see Instance#put
   def put(s)
     @inst.put s
   end
 
-  # @see Ruff::Standard::State::Instance#with_init
+  # @see Instance#with_init
   def with_init(init, &task)
     @inst.with_init init, &task
   end
 
-  # @see Ruff::Standard::State::Instance#with
+  # @see Instance#with
   def with(&task)
     @inst.with(&task)
   end
 
   module_function :get, :put, :modify, :with, :with_init
 
-  # @see Ruff::Standard::Instance#eff
+  # @see Instance#eff
   attr_reader :eff
 end

data/lib/ruff/standard/util.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Util end
+
+class Util::FnStack
+  def initialize
+    @queue = []
+  end
+
+  def enqueue(fn)
+    @queue.push fn
+  end
+
+  def dequeue
+    hd = @queue.pop
+    hd[] unless hd.nil?
+  end
+
+  def cons(hd)
+    queue_ = @queue.dup
+    queue_.push hd
+  end
+end
+
+class Util::Ref
+  def initialize(v)
+    @v = v
+  end
+
+  def get
+    @v
+  end
+
+  def set(v_)
+    @v = v_
+  end
+end
+
+module Util::ADT
+  def create
+    Class.new do
+      def initialize(v)
+        @value = v
+      end
+
+      def get
+        @value
+      end
+    end
+  end
+
+  module_function :create
+end

data/lib/ruff/version.rb

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

data/version

@@ -1 +1 @@
-1.2.0
+1.3.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruff
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - nymphium
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-04 00:00:00.000000000 Z
+date: 2019-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -57,6 +57,8 @@ files:
 - 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/CurrentTime.html
 - docs/Ruff/Standard/CurrentTime/Instance.html
 - docs/Ruff/Standard/Defer.html
@@ -68,6 +70,10 @@ files:
 - docs/Ruff/Throws.html
 - docs/Ruff/Throws/Eff.html
 - docs/Ruff/Throws/Resend.html
+- docs/Util.html
+- docs/Util/ADT.html
+- docs/Util/FnStack.html
+- docs/Util/Ref.html
 - docs/_index.html
 - docs/class_list.html
 - docs/css/common.css
@@ -87,10 +93,12 @@ files:
 - lib/ruff/handler.rb
 - lib/ruff/objects.rb
 - lib/ruff/standard.rb
+- lib/ruff/standard/async.rb
 - lib/ruff/standard/current_time.rb
 - lib/ruff/standard/defer.rb
 - lib/ruff/standard/measure_time.rb
 - lib/ruff/standard/state.rb
+- lib/ruff/standard/util.rb
 - lib/ruff/version.gen.sh
 - lib/ruff/version.rb
 - ruff.gemspec