cont 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 493e03fe958a5776f33b1bbd144830a66893bd02e75a6b93fc2dc3b836817a51
+  data.tar.gz: 250d5cdad63e5cafd2b90e34ff90af5d6d3b903706a4edec0e6b4667f7ff0031
+SHA512:
+  metadata.gz: e5cee2b1b33182f7935345da4efadbd4567fd4f89e75f6f07b4400b8dc8292102508500caba9d56504e1ceeb1c1d43badcded4004e524541ac5daf0eaa1e1d3e
+  data.tar.gz: 68b9aec29911124c3e5e2a28932512ace12bdace81ac6ff5302b575f1bdef30634e2203657418dfd35d2f9403237281ee57befbded131c4a9a153f29e811cbe7

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Masaya Taniguchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+# Cont Library
+
+## Overview
+
+The `Cont` module is a Ruby library that provides an implementation of
+continuations using the `fiber` library. Continuations are advanced control flow
+constructs that allow you to save the state of a computation at a certain point
+and then resume it later. This library is useful for managing complex control
+flows and implementing advanced features like coroutines, generators, and
+cooperative multitasking.
+
+## Installation
+
+To use the `Cont` library, simply require it in your Ruby project:
+
+```ruby
+require 'cont'
+```
+
+## Usage
+
+### `Cont.reset`
+
+`Cont.reset` limits the continuation to the current block.
+It takes a block of code and returns the result of that block.
+
+#### Example
+
+```ruby
+result = Cont.reset do
+  # Your code here
+  42
+end
+puts result # => 42
+```
+
+### `Cont.shift`
+
+`Cont.shift` captures the current continuation and allows you to resume it.
+It takes a block of code, which should call a lambda to resume the continuation.
+
+#### Example
+
+```ruby
+result = Cont.reset do
+  Cont.shift do |cont|
+    cont.call(42) + 1
+  end
+end
+puts result # => 42
+```
+
+## Exceptions
+
+### `Cont::DeadContinuationError`
+
+This exception is raised when an attempt is made to resume a dead continuation.
+
+### `Cont::UnexpectedStatusError`
+
+This exception is raised when an unexpected status is encountered.
+
+## License
+
+MIT License
+
+Copyright (c) 2024 Masaya Taniguchi

data/lib/cont/single_prompt.rb

@@ -0,0 +1,64 @@
+module SinglePrompt
+
+  # The 'fiber' library is required for the implementation of continuations.
+  require 'fiber'
+
+  # Exception for handling dead continuation
+  class DeadContinuationError < StandardError; end
+
+  # Exception for handling unexpected statuses
+  class UnexpectedStatusError < StandardError; end
+
+  # Limit the continuation to the current block.
+  #
+  # @yield [block] The block of code to be run
+  # @return [Object] The result of the block.
+  def self.reset(&block)
+    prompt0(&block)
+  end
+
+  # Capture the current continuation.
+  #
+  # @yield [block] The block of code to be run
+  # @return [Object] The result of the block.
+  def self.shift(&block)
+    control0 do |fiber|
+      prompt0 do
+        block.call lambda { |value|
+          prompt0 do
+            raise DeadContinuationError.new unless fiber.alive?
+            run(fiber, :resume, lambda { value })
+          end
+        }
+      end
+    end
+  end
+
+  private
+
+  def self.run(fiber, *args)
+    status, value = fiber.resume(*args)
+    case status
+    when :return
+      value
+    when :capture
+      value.call(fiber)
+    else
+      raise UnexpectedStatusError.new("unexpected status: #{status}")
+    end
+  end
+
+  def self.prompt0(&block)
+    fiber = Fiber.new do
+      Fiber.yield(:return, block.call())
+    end
+    run(fiber)
+  end
+
+  def self.control0(&block)
+    status, f = Fiber.yield(:capture, block)
+    raise UnexpectedStatusError.new("unexpected status: #{status}") \
+      unless status == :resume
+    f.call()
+  end
+end

data/lib/cont/version.rb

@@ -0,0 +1,3 @@
+module Cont
+  VERSION = '0.1.0'.freeze
+end

data/lib/cont.rb

@@ -0,0 +1,26 @@
+# The Cont module provides methods for working with continuations.
+# Continuations are a way to save the execution state of a program
+# so that it can be resumed later. They are used for advanced control
+# flow structures such as coroutines, generators, and so on.
+#
+# Ruby have a built-in support for continuations, but it is deprecated
+# and should not be used. This implementation uses the 'fiber' library
+# based on https://github.com/minoki/delimited-continuations-in-lua .
+# That library is released under the MIT license:
+# https://github.com/minoki/delimited-continuations-in-lua/blob/master/LICENSE .
+#
+# Caution 1: The continuations of this implementation are 'one-shot',
+# So they can only be resumed once. If you try to resume a dead
+# continuation, an exception will be raised.
+#
+# Caution 2: This implementation is based on the 'fiber' library,
+# so you should not crate a new fiber in a continuation block.
+#
+# Copyright (c) 2024 Masaya Taniguchi
+# This software is released under the MIT License.
+
+require_relative 'cont/single_prompt'
+
+module Cont
+  include SinglePrompt
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: cont
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Masaya Taniguchi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+description: |
+  The Cont module provides methods for working with continuations.
+  Continuations are a way to save the execution state of a program
+  so that it can be resumed later. They are used for advanced control
+  flow structures such as coroutines, generators, and so on.
+
+  Ruby have a built-in support for continuations, but it is deprecated
+  and should not be used. This implementation uses the 'fiber' library
+  based on https://github.com/minoki/delimited-continuations-in-lua .
+  That library is released under the MIT license.
+
+  Caution: The continuations of this implementation are 'one-shot',
+  So they can only be resumed once. If you try to resume a dead
+  continuation, an exception will be raised.
+email:
+- ta2ghc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/cont.rb
+- lib/cont/single_prompt.rb
+- lib/cont/version.rb
+homepage: https://github.com/tani/ruby-cont
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.25
+signing_key:
+specification_version: 4
+summary: Cont provides methods for working with continuation
+test_files: []