affect 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ef9c069aa2f0077d7cbf108e9f9a36aaf2a1808fdc1636d37e40333b6cfc2e0
-  data.tar.gz: 54e9f068ed3fecdb8dd624efb41b9540ecb1259b569636fca193a7c0fc27e172
+  metadata.gz: a0f0602d116f929cf06c3e842419c2bf6b74ccfe87e7af297ccb5cd9a56ea33e
+  data.tar.gz: 2b04f09256756633e268cf29d263b870b5065cf5e2bf6a3f55cdac1465a14a0b
 SHA512:
-  metadata.gz: d2aadb70ccf3ea71c0dfa794cbe33424a4b2ab74ec6208d0137e3664149320a748199dc6c4944dd677ed3f4ace979e6411878165918e4bbd68c539eadbaa02cc
-  data.tar.gz: 983d269425f777d7aae8ce64251b293a170a8dc5dfd7a57a46bc0827e7e81c0bfaadd3111d9e578a15676d0621526278054a17c06e6b7c7bd098f2f8d26dfc66
+  metadata.gz: aecfbd76f53bf973d597b8ce6233a5a704ef22a2e02b20f88e9b941653d8be4866d5237d9e16c562409e74f7cc86643dfd91384a8707ca82b16e7dd8dd0a5807
+  data.tar.gz: 84683a1c5b7f63ee0ab5bfcdb8cd757faef817fd4c0b5da21b93ff10741ca549773068d4ffc7ac34ae95c43a8a9df23f9af0a6908e88c87548399a3699d098ae

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+0.2 2019-08-26
+--------------
+
+* Add alternative effects implementation using fibers
+* Add implementation of delimited continuations
+* Rewrite, change API to use capture/perform
+
+0.1 2019-07-30
+--------------
+
+* First implementation

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    affect (0.1)
+    affect (0.2)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,4 +1,4 @@
-# Affect - structured side effects for functional Ruby
+# Affect - algebraic effects for Ruby
 
 [INSTALL](#installing-affect) |
 [TUTORIAL](#getting-started) |
@@ -13,6 +13,10 @@ functional programs. Affect implements algebraic effects in Ruby, but can also
 be used to implement patterns that are orthogonal to object-oriented
 programming, such as inversion of control and dependency injection.
 
+In addition, Affect includes an alternative implementation of algebraic effects
+using Ruby fibers, as well as an implementation of delimited continuations using
+`callcc` (currently deprecated).
+
 > **Note**: Affect does not pretend to be a *complete, theoretically correct*
 > implementation of algebraic effects. Affect concentrates on the idea of 
 > [effect contexts](#the-effect-context). It does not deal with continuations,
@@ -20,11 +24,12 @@ programming, such as inversion of control and dependency injection.
 
 ## Installing Affect
 
-```bash
-$ gem install affect
+```ruby
+# In your Gemfile
+gem 'affect'
 ```
 
-Or add it to your Gemfile, you know the drill.
+Or install it manually, you know the drill.
 
 ## Getting Started
 
@@ -57,149 +62,146 @@ require 'affect'
 
 def mul(x, y)
   # assume LOG is a global logger object
-  Affect :log, "called with #{x}, #{y}"
+  Affect.perform :log, "called with #{x}, #{y}"
   x * y
 end
 
-Affect.wrap {
+Affect.capture(
+  log: { |message| puts "#{Time.now} #{message} (this is a log message)" }
+) {
   puts "Result: #{ mul(2, 3) }"
-}.on(:log) { |message|
-  puts "#{Time.now} #{message} (this is a log message)"
-}.()
 ```
 
-In the example above, we replace the call to `LOG.info` with an invocation of a
-`LogIntent` instance. When the intent is passed to `Affect`, the corresponding
-handler is called in order to perform the intent.
+In the example above, we replace the call to `LOG.info` with the performance of
+an *intent* to log a message. When the intent is passed to `Affect`, the
+corresponding handler is called in order to perform the effect.
 
 In essence, by separating the performance of side effects into effect intents,
 and effect handlers, we have separated the what from the how. The `mul` method
 is no longer concerned with how to log the message it needs to log. There's no 
-hardbaked reference to a `Log` object, and no logging API to follow. Instead,
-the *intent* to log a message is passed on to `Affect`, which in turn runs the
+hardbaked reference to a `LOG` object, and no logging API to follow. Instead,
+the *intent* to log a message is passed on to Affect, which in turn runs the
 correct handler that actually does the logging.
 
-## Performing side effects
+## The effect context
+
+In Affect, effects are performed and handled using an *effect context*. The 
+effect context has one or more effect handlers, and is then used to run code
+that performs effects, handling effect intents by routing them to the correct
+handler.
 
-Side effects are performed by calling `Affect.perform` or simply `Affect()` with
-a specification of the effect to be performed:
+Effect contexts are defined using either `Affect()` or the shorthand
+`Affect.capture`:
 
 ```ruby
-Affect.perform :foo
+ctx = Affect(log: -> msg { log_msg(msg) })
+ctx.capture { do_something }
 
-# or:
-Affect :foo
+# or
+Affect.capture(log: -> msg { log_msg(msg) }) { do_something }
 ```
 
-You can also pass along more arguments. Those will in turn be passed to the
-effect handler:
+The `Affect.capture` method can be called in different manners:
 
 ```ruby
-Affect :log, 'my message'
+Affect.capture(handler_hash) { body }
+Affect.capture(handler_proc) { body }
+Affect.capture(body, handler_hash)
+Affect.capture(body, handler_proc)
 ```
 
-Effects can be represented using any Ruby object, but in a relatively complex
-application might be best represented using classes or structs signifying the
-*intent* to perform an effect:
+... where `body` is the code to be executed, `handler_hash` is a hash of effect
+handling procs, and `handler_proc` is a default effect handling proc.
+
+### Nested effect contexts
+
+Effect contexts can be nested. When an effect context does not know how to
+handle a certain effect intent, it passes it on to the parent effect context.
+If no handler has been found for the effect intent, an error is raised:
 
 ```ruby
-LogIntent = Struct.new(:msg)
+# First effect context
+Affect.capture(log: ->(msg) { LOG.info(msg) }) {
+  Affect.perform :log, 'starting'
+  # Second effect context
+  Affect.capture(log: ->(msg) { }) {
+    Affect.perform :log, 'this message will not be logged'
+  }
+  Affect.perform :log, 'stopping'
 
-Affect LogIntent.new('my message')
+  Affect.perform :foo # raises an error, as no handler is given for :foo
+}
 ```
 
-When representing effects using symbols, Affect provides a shorthand way to 
-perform effects by calling methods directly on the `Affect` module:
+
+## Effect handlers
+
+Effect handlers map different effects to a proc or a callable object. When an
+effect is performed, Affect will try to find the relevant effect handler by
+looking at its *signature* (given as the first argument), and then matching
+first by value, then by class. Thus, the effect signature can be either a value,
+or a class (normally used when creating intent classes).
+
+The simplest, most idiomatic way to define effect handlers is to use symbols as
+effect signatures:
 
 ```ruby
-Affect.log('my message')
+Affect(log: -> msg { ... }, ask: -> { ... })
 ```
 
-Finally, effects should be performed inside of an effect context, by invoking
-`Affect::Context#call`. Mostly, you'll want to use the callable shorthand 
-`.() { ... }`:
+A catch-all handler can be defined by calling `Affect()` with a block:
 
 ```ruby
-def add(x, y)
-  Affect :log, "adding #{x} and #{y}..."
-  x + y
+Affect do |eff, *args|
+  case eff
+  when :log
+    ...
+  when :ask
+    ...
+  end
 end
-
-Affect.on(:log) { |msg| puts "#{Time.now} #{msg}" }.() {
-  result = add(2, 2)
-  puts "result: #{result}"
-}
 ```
 
-## handling side effects
+Note that when using a catch-all handler, no error will be raised for unhandled
+effects.
+
+## Performing side effects
 
-Side effect handlers can be defined using the `Affect.on` or `Affect.handle`
-methods. `Affect.on` is used to register one or more effect handlers:
+Side effects are performed by calling `Affect.perform` or simply
+`Affect.<intent>` along with one or more parameters:
 
 ```ruby
-# register a single effect handler
-Affect.on(:log) { |msg| puts "#{Time.now} #{msg}" }
-
-# register multiple effect handlers by passing in a hash
-Affect.on(
-  log: ->(msg) { puts "#{Time.now} #{msg}" },
-  ask: -> { gets.chomp }
-)
+Affect.perform :foo
+
+# or:
+Affect.foo
 ```
 
-`Affect.handle` is used as a catch-all handler:
+Any parameters will be passed along to the effect handler:
 
 ```ruby
-Affect.handle do |effect, *args|
-  case effect
-  when :log   then puts "#{Time.now} #{msg}"
-  when :ask   then gets.chomp
-  end
-end
+Affect.perform :log, 'my message'
 ```
 
-Note that when `Affect.handle` is used to handle effects, no error will be
-raised for unhandled effects.
-
-## The effect context
-
-Affect defines an effect context which is unique to *each thread or fiber*.
-Effect contexts can be thought of as stack frames containing information about
-effect handlers. When effects are invoked using method calls on `Affect`, the
-call is routed to the most current effect context. If the current effect context
-does not know how to handle a certain effect, the call will bubble up the stack
-of effect contexts until a handler is found:
+Effects intents can be represented using any Ruby object, but in a relatively
+complex application might best be represented using classes or structs:
 
 ```ruby
-# First effect context
-Affect.on(:log) { |msg| LOG.info(msg) },
-).() {
-  log("starting")
-  # Second effect context
-  Affect.on(
-    log: ->(*args) { }
-  ).() {
-    log("this message will not be logged")
-  }
-  log("stopping")
-}
-```
+LogIntent = Struct.new(:msg)
 
-## Putting it all together
+Affect.perform LogIntent.new('my message')
+```
 
-The Affect API uses method chaining to add effect handlers and finally, execute
-the application code. Multiple effect handlers can be chained as follows:
+When using symbols as effect signatures, Affect provides a shorthand way to 
+perform effects by calling methods directly on the `Affect` module:
 
 ```ruby
-Affect
-  .on(:ask) { ... }
-  .on(:tell) { ... }
-  .() do
-    ...
-  end
+Affect.log('my message')
 ```
 
-## Other usages
+## Other uses
+
+In addition to isolating side-effects, Affect can be used for other purposes:
 
 ### Dependency injection
 
@@ -255,10 +257,10 @@ def pattern_count(pattern)
   found_count
 end
 
-Affect.on(
+Affect(
   gets: -> { Kernel.gets },
   log: -> { |msg| STDERR << "#{Time.now} #{msg}" }
-).() {
+).capture {
   pattern = /#{ARGV[0]}/
   count = pattern_count(pattern)
   puts count
@@ -282,8 +284,10 @@ class PatternCountTest < Minitest::Test
   def test_correct_count
     text = StringIO.new("foo\nbar")
 
-    Affect.on(:gets) { text.gets }.on(:log) { |msg| } # ignore
-    .() {
+    Affect(
+      gets: -> { text.gets },
+      log:  -> |msg| {} # ignore
+    .capture {
       count = pattern_count(/foo/)
       assert_equal(1, count)
     }
@@ -295,6 +299,4 @@ end
 
 Affect is a very small library designed to do very little. If you find it
 compelling, have encountered any problems using it, or have any suggestions for
-improvements, please feel free to contribute issues or pull requests.
-
-## 
+improvements, please feel free to contribute issues or pull requests.

data/lib/affect.rb

@@ -2,36 +2,28 @@
 
 # Affect module
 module Affect
-  Abort = Object.new # Used as an abort intent
+  extend self
 
-  # Effect context
+  # Implements an effects context
   class Context
-    def initialize(&block)
-      @closure = block
-      @handlers = {}
+    def initialize(handlers = nil, &block)
+      @handlers = handlers || { nil => block || -> {} }
     end
 
-    def on(effect, &block)
-      if effect.is_a?(Hash)
-        @handlers.merge!(effect)
-      else
-        @handlers[effect] = block
-      end
-      self
-    end
+    attr_reader :handlers
 
-    def handle(&block)
-      @handlers[nil] = block
-      self
+    def handler_proc
+      proc { |effect, *args| handle(effect, *args) }
     end
 
     def perform(effect, *args)
-      if (handler = find_handler(effect))
+      handler = find_handler(effect)
+      if handler
         call_handler(handler, effect, *args)
-      elsif @parent_context
-        @parent_context.perform(effect, *args)
+      elsif @parent
+        @parent.perform(effect, *args)
       else
-        raise "No effect handler for #{effect.inspect}"
+        raise "No handler found for #{effect.inspect}"
       end
     end
 
@@ -40,7 +32,7 @@ module Affect
     end
 
     def call_handler(handler, effect, *args)
-      if handler.arity == 0
+      if handler.arity.zero?
         handler.call
       elsif args.empty?
         handler.call(effect)
@@ -49,58 +41,65 @@ module Affect
       end
     end
 
-    def abort!(value = nil)
-      throw Abort, (value || Abort)
+    @@current = nil
+    def self.current
+      @@current
     end
 
-    def call(&block)
-      current_thread = Thread.current
-      @parent_context = current_thread[:__affect_context__]
-      current_thread[:__affect_context__] = self
-      catch(Abort) do
-        (block || @closure).call
-      end
+    def capture
+      @parent, @@current = @@current, self
+      catch(:escape) { yield }
     ensure
-      current_thread[:__affect_context__] = @parent_context
+      @@current = @parent
     end
-  end
 
-  class << self
-    def wrap(&block)
-      Context.new(&block)
+    def escape(value = nil)
+      throw :escape, (block_given? ? yield : value)
     end
+  end
 
-    def call(&block)
-      Context.new(&block).call
-    end
+  def capture(*args, &block)
+    block, handlers = block_and_handlers_from_args(*args, &block)
+    handlers = { nil => handlers } if handlers.is_a?(Proc)
+    Context.new(handlers).capture(&block)
+  end
 
-    def on(effect, &block)
-      Context.new.on(effect, &block)
+  def block_and_handlers_from_args(*args, &block)
+    case args.size
+    when 1 then block ? [block, args.first] : [args.first, nil]
+    when 2 then args
+    else [block, nil]
     end
+  end
 
-    def handle(&block)
-      Context.new.handle(&block)
+  def perform(effect, *args)
+    unless (ctx = Context.current)
+      raise 'perform called outside capture block'
     end
 
-    def current_context
-      Thread.current[:__affect_context__] || (raise 'No effect context present')
-    end
+    ctx.perform(effect, *args)
+  end
 
-    def perform(effect, *args)
-      current_context.perform(effect, *args)
+  def escape(value = nil, &block)
+    unless (ctx = Context.current)
+      raise 'escape called outside capture block'
     end
 
-    alias_method :method_missing, :perform
+    ctx.escape(value, &block)
+  end
 
-    def abort!(value = nil)
-      current_context.abort!(value)
-    end
+  def respond_to_missing?(*)
+    true
+  end
+
+  def method_missing(*args)
+    perform(*args)
   end
 end
 
-# Kernel extension
+# Kernel extensions
 module Kernel
-  def Affect(effect, *args)
-    Affect.current_context.perform(effect, *args)
+  def Affect(handlers = nil, &block)
+    Affect::Context.new(handlers, &block)
   end
 end

data/lib/affect/cont.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# adapted from:
+#   https://github.com/mveytsman/DelimR/blob/master/lib/delimr.rb
+
+require 'continuation'
+
+module Affect
+  module Cont
+    extend self
+
+    # holds objects of the form [bool, Continuation]
+    # where bool siginifies a 
+    @@stack = []
+
+    def abort(v)
+      (@@stack.pop)[1].(v)
+    end
+
+    def capture(&block)
+      callcc { |outer|
+        @@stack << [true, outer]
+        abort(block.())
+      }
+    end
+
+    def escape
+      callcc do |esc|
+        unwound_continuations = unwind_stack
+        cont_proc = lambda { |v|
+          callcc do |ret|
+            @@stack << [true, ret]
+            unwound_continuations.each { |c| @@stack << [nil, c] }
+            esc.call(v)
+          end
+        }
+        abort(yield(cont_proc))
+      end
+    end
+
+    def unwind_stack
+    unwound = []
+      while @@stack.last && !(@@stack.last)[0]
+        unwound << (@@stack.pop)[1]
+      end
+      unwound.reverse
+    end
+  end
+end

data/lib/affect/fiber.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+# Affect module
+module Affect
+  module Fiber
+    extend self
+
+    class Intent
+      def initialize(*args)
+        @args = args
+      end
+
+      attr_reader :args
+    end
+
+    class Escape < Intent
+      def initialize(&block)
+        @block = block
+      end
+
+      def call(*args)
+        @block.(*args)
+      end
+    end
+
+    def capture(*args, &block)
+      block, handler = case args.size
+        when 1 then block ? [block, args.first] : [args.first, nil]
+        when 2 then args
+        else [block, nil]
+      end
+
+      f = Fiber.new(&block)
+      v = f.resume
+      loop do
+        break v unless f.alive? && v.is_a?(Intent)
+
+        if v.is_a?(Escape)
+          break v.()
+        else
+          v = f.resume(handler.(*v.args))
+        end
+      end
+    end
+
+    def perform(*args)
+      Fiber.yield Intent.new(*args)
+    rescue FiberError
+      raise RuntimeError, 'perform called outside of capture'
+    end
+
+    def escape(value = nil, &block)
+      block ||= proc { value }
+      Fiber.yield Escape.new(&block)
+    rescue FiberError
+      raise RuntimeError, 'escape called outside of capture'
+    end
+
+    def method_missing(*args)
+      perform(*args)
+    end
+
+    class Context
+      def initialize(handlers = nil, &block)
+        @handlers = handlers || { nil => block || -> { } }
+      end
+
+      attr_reader :handlers
+
+      def handler_proc
+        proc { |effect, *args| handle(effect, *args) }
+      end
+
+      def handle(effect, *args)
+        handler = find_handler(effect)
+        if handler
+          call_handler(handler, effect, *args)
+        else
+          begin
+            Fiber.yield Intent.new(effect, *args)
+          rescue FiberError
+            raise RuntimeError, "No handler found for #{effect.inspect}"
+          end
+        end
+      end
+
+      def find_handler(effect)
+        @handlers[effect] || @handlers[effect.class] || @handlers[nil]
+      end
+
+      def call_handler(handler, effect, *args)
+        if handler.arity == 0
+          handler.call
+        elsif args.empty?
+          handler.call(effect)
+        else
+          handler.call(*args)
+        end
+      end
+
+      def capture(&block)
+        Affect.capture(block, handler_proc)
+      end
+    end
+  end
+end
+
+module Kernel
+  def Affect(handlers = nil, &block)
+    Affect::Context.new(handlers, &block)
+  end
+end

data/lib/affect/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Affect
-  VERSION = '0.1'
+  VERSION = '0.2'
 end

data/test/test_affect.rb

@@ -4,130 +4,138 @@ require 'minitest/autorun'
 require 'bundler/setup'
 require 'affect'
 
-class AffectAPITest < Minitest::Test
-  def test_that_perform_raises_on_no_handler
-    assert_raises RuntimeError do
-      Affect.wrap {
-        Affect.perform :foo
-      }.on(:bar) {
-        :baz
-      }.()
-    end
+class AffectTest < Minitest::Test
+  include Affect
 
-    # using method call on Affect
-    assert_raises RuntimeError do
-      Affect.wrap {
-        Affect.foo
-      }.()
-    end
+  def test_capture_with_different_arities
+    assert_equal :foo, capture { :foo }
+    assert_equal :foo, capture(-> { :foo })
+    
+    assert_equal :bar, capture(-> { perform(:foo) }, ->(e) { e == :foo && :bar })
 
-    # no raise
-    Affect.wrap {
-      Affect.perform :foo
-    }.on(:foo) {
-      :bar
-    }.()
   end
 
-  def test_that_emitted_effect_is_performed
-    counter = 0
-    Affect.wrap {
-      3.times { Affect.perform :incr }
-    }.on(:incr) {
-      counter += 1
-    }.()
+  def test_escape
+    assert_raises(RuntimeError) { escape(:foo) }
+    assert_raises(RuntimeError) { escape { :foo } }
 
-    assert_equal(3, counter)
+    assert_equal :bar, capture { [:foo, escape(:bar)] }
+    assert_equal :baz, capture { [:foo, escape { :baz }] }
   end
 
-  def test_that_api_methods_return_context
-    o = Affect.wrap {
-      Affect.perform :foo
+  def test_effect_handler_dsl
+    v = 1
+    ctx = Affect(
+      get: -> { v },
+      set: ->(x) { v = x }
+    )
+
+    assert_kind_of Affect::Context, ctx
+
+    final = ctx.capture {
+      [
+        perform(:get),
+        perform(:set, 2),
+        perform(:get),
+        Affect.get,
+        Affect.set(3),
+        Affect.get
+      ]
     }
-    assert_kind_of(Affect::Context, o)
 
-    o = Affect.on(:foo) {
-      :bar
-    }
-    assert_kind_of(Affect::Context, o)
+    assert_equal [1, 2, 2, 2, 3, 3], final
+  end
 
-    o = Affect.handle { }
-    assert_kind_of(Affect::Context, o)
+  def test_context_missing_handler
+    assert_raises RuntimeError do
+      Affect(foo: -> { :bar }).capture { perform :baz }
+    end
+  end
+
+  def test_context_wildcard_handler
+    ctx = Affect do |e| e + 1; end
+    assert_equal 3, ctx.capture { perform(2) }
   end
 
   def test_that_contexts_can_be_nested
     results = []
-    o = Affect.wrap {
-      Affect.perform :foo
-      Affect.perform :bar
 
-      Affect.wrap {
-        Affect.perform :foo
-        Affect.perform :bar
-      }
-      .on(:bar) { results << :baz }
-      .()
-    }
-    .on(:foo) { results << :foo }
-    .on(:bar) { results << :bar }
-    .()
+    ctx2 = Affect(bar: -> { results << :baz })
+    ctx1 = Affect(
+      foo: -> { results << :foo },
+      bar: -> { results << :bar }
+    )
 
-    assert_equal([:foo, :bar, :foo, :baz], results)
-  end
-
-  def test_that_effects_can_be_emitted_as_method_calls_on_Affect
-    results = []
-    o = Affect.wrap {
+    ctx1.capture {
       Affect.foo
       Affect.bar
 
-      Affect.wrap {
+      ctx2.capture {
         Affect.foo
         Affect.bar
       }
-      .on(:bar) { results << :baz }
-      .()
     }
-    .on(:foo) { results << :foo }
-    .on(:bar) { results << :bar }
-    .()
 
     assert_equal([:foo, :bar, :foo, :baz], results)
   end
 
-  def test_that_abort_can_be_called_from_wrapped_code
-    effects = []
-    Affect.handle { |o| effects << o }.() do
-      Affect 1
-      Affect.abort!
-      Affect 2
-    end
-
-    assert_equal([1], effects)
-  end
-
-  def test_that_abort_causes_call_to_return_optional_value
-    o = Affect.() { Affect.abort! }
-    assert_equal(Affect::Abort, o)
-
-    o = Affect.() { Affect.abort!(42) }
-    assert_equal(42, o)
+  def test_that_escape_provides_return_value_of_capture
+    assert_equal 42, capture { 2 * escape { 42 } }
   end
 
   class I1; end
-
   class I2; end
 
   def test_that_intent_instances_are_handled_correctly
     results = []
-    Affect
-      .on(I1) { results << :i1 }
-      .on(I2) { results << :i2 }
-      .() {
-        Affect I1.new
-        Affect I2.new
+    Affect(
+      I1 => -> { results << :i1 },
+      I2 => -> { results << :i2 }
+    ).capture {
+      perform I1.new
+      perform I2.new
     }
 
     assert_equal([:i1, :i2], results)
   end
+
+  # doesn't work with callback-based affect
+  def test_that_capture_can_work_across_fibers_with_transfer
+    require 'fiber'
+    f1 = Fiber.new { |f| escape(:foo) }
+    f2 = Fiber.new { f1.transfer(f2) }
+
+    # assert_equal :foo, capture { f2.resume }
+  end
+
+  # doesn't work with fiber-based Affect
+  def test_that_capture_can_work_across_fibers_with_yield
+    f1 = Fiber.new { |f| escape(:foo) }
+    f2 = Fiber.new { f1.resume }
+
+    # assert_equal :foo, capture { f2.resume }
+  end
 end
+
+class ContTest < Minitest::Test
+  require 'affect/cont'
+
+  Cont = Affect::Cont
+
+  def test_that_continuation_is_provided_to_escape
+    k = Cont.capture { 2 * Cont.escape { |cont| cont } }
+    assert_kind_of Proc, k
+  end
+
+  def test_that_continuation_completes_the_computation_in_capture
+    k = Cont.capture { 2 * Cont.escape { |cont| cont } }
+    assert_equal 12, k.(6)
+  end
+
+  def test_that_continuation_can_be_called_multiple_times
+    k = Cont.capture { 2 * Cont.escape { |cont| cont } }
+    assert_equal 4, k.(2)
+    assert_equal 6, k.(3)
+    assert_equal 8, k.(4)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: affect
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-30 00:00:00.000000000 Z
+date: 2019-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -32,16 +32,20 @@ extra_rdoc_files:
 - README.md
 files:
 - ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
 - README.md
+- TODO.md
 - affect.gemspec
 - examples/fact.rb
 - examples/greet.rb
 - examples/logging.rb
 - examples/pat.rb
 - lib/affect.rb
+- lib/affect/cont.rb
+- lib/affect/fiber.rb
 - lib/affect/version.rb
 - test/test_affect.rb
 homepage: http://github.com/digital-fabric/affect