ractor-server 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '029685fbbe91ed839a800417dfe53141a7bbce3fb5058575f4607a7956872ccc'
+  data.tar.gz: 71376351108500ba31e6161ed4229fc836bc90b49d1992c8e0d9cbe4a07a8678
+SHA512:
+  metadata.gz: f728a4a7862ed48732aaf688480e0f5ae64af885a02175b34bbfdec6185a6eb972680ce5d279b24d3d78ef8e9ac26b5a67102f8b1183d227c55b08a55138b138
+  data.tar.gz: 8166754425d64a1747fb3f13b95e2a4a5d1a8c70e1dde578841f161e4aa645dbe1adfafb75a8dcfa63f4fb62b52f9e7dcf7f352597ecec3898818e65674ee1ab

data/.github/workflows/main.yml

@@ -0,0 +1,49 @@
+name: CI
+
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+
+jobs:
+  tests:
+    name: >-
+      Specs | ${{ matrix.ruby }}
+    runs-on: ${{ matrix.os }}-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu ]
+        ruby: [ '3.0', head ]
+    steps:
+      - name: checkout
+        uses: actions/checkout@v2
+      - name: set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: install dependencies
+        run: bundle install --jobs 3 --retry 3
+      - name: spec
+        run:  bundle exec rake
+  internal_investigation:
+    name: >-
+      Coding Style
+    runs-on: ${{ matrix.os }}-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu ]
+        ruby: [ 2.7 ]
+    steps:
+      - name: checkout
+        uses: actions/checkout@v2
+      - name: set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: install dependencies
+        run: bundle install --jobs 3 --retry 3
+      - name: internal investigation
+        run: bundle exec rubocop

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+Gemfile.lock
+.rubocop-https-*

data/.pryrc

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+$LOAD_PATH << './lib'
+require 'ractor/server'
+
+# Pry.config.hooks.add_hook(:when_started, :set_context) do |binding, options, pry|
+#   if binding.eval('self').class == Object # true when starting `pry`
+#     # false when called from binding.pry
+#     pry.input = StringIO.new('cd Ractor::Server')
+#   end
+# end

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,27 @@
+inherit_from:
+  - https://raw.githubusercontent.com/ractor-tools/rubocop-ractor-tools/master/.rubocop.yml
+
+AllCops:
+  TargetRubyVersion: 3.0
+
+# Move:
+
+Layout/EmptyLineAfterMagicComment:
+  Enabled: false # https://github.com/rubocop-hq/rubocop/issues/9327
+Style/RescueModifier:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Style/MutableConstant:
+  Enabled: false # https://github.com/rubocop-hq/rubocop/issues/9328
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: consistent_comma
+
+Naming/MethodParameterName:
+  AllowedNames:
+    - rq
+# Local:
+
+Metrics/MethodLength:
+  Max: 16

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at github@marc-andre.ca. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ractor-server.gemspec
+gemspec
+
+gem 'rake'
+
+gem 'rspec'
+gem 'rspec-its'
+
+gem 'rubocop'
+
+gem 'pry-byebug'
+
+gem 'backports', '~> 3.20'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Marc-Andre Lafortune
+
+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,335 @@
+# Ractor::Server
+
+## Usage
+
+### Intro
+
+This gem streamlines communication to a Ractor:
+* a "Server" that makes its methods available (think Elixir/Erlang's `GenServer`)
+* a "Client" that is immutable (Ractor shareable) and can call a "Server" from any Ractor.
+
+Any class can `include Ractor::Server` and this automatically creates an interface:
+
+```ruby
+class RactorHash < Hash
+  include Ractor::Server
+end
+
+H = RactorHash.start
+
+Ractor.new { H[:example] = 42 }.take
+puts Ractor.new { H[:example] }.take # => 42
+```
+
+Calls with blocks are atomic yet allow reentrant calls:
+
+```ruby
+ractors = 3.times.map do |i|
+  Ractor.new(i) do |i|
+    H.fetch_values(:foo, :bar) do |val|
+      H[val] = i
+    end
+  end
+end
+
+puts H # => {:example => 42, :foo => 0, :bar => 0}
+       # (maybe 0 will be 1 or 2, but both will be same)
+```
+
+The first ractor to call `fetch_values` will have its block called twice; only the `fetch_values` has completed will the other Ractors have their calls to `fetch_values` run. The block is reentrant as it calls `[]=`; that call will not wait.
+
+The implementation relies on three layers of functionality.
+
+### Low-level API: `Request`
+
+The first layer is the concept of a `Request` that uniquely identifies a message sent to a Ractor.
+
+This enables a way to safely reply to a request:
+
+```ruby
+using Ractor::Server::Talk
+
+ractor = Ractor.new do
+  request, data = receive_request
+  puts data # => :example
+  request.send(:hello)
+end
+
+request = ractor.send_request(:example)
+response_request, result = request.receive
+puts result # => :hello
+```
+
+#### `Request` is an envelope
+
+The `Request` itself contains no data other than the initiating Ractor (`Request#initiating_ractor`) and if it is a reply to another `Request` (`Request#response_to`):
+
+```ruby
+request.initiating_ractor == Ractor.current # => true
+response_request.initiating_ractor == ractor # => true
+request.response_to # => nil
+response_request.response_to # => request
+```
+
+Note that a `Request` is immutable and thus Ractor-shareable irrespective of the data that accompanies it.
+
+#### Nesting `Request`s
+
+One may reply to a `Request` any number of times; it is up to the requester to receive the proper amount of times.
+
+A response to a `Request` is itself a `Request`; `Requests` may be nested as deeply as required:
+
+```ruby
+# as above...
+ractor = Ractor.new do
+  request, data = receive_request
+  puts data # => :example
+  request.send(:hello)
+  response_request = request.send(:world)
+  other_request, data = response_request.receive
+  puts data # => :inner
+  # ...
+end
+
+request = ractor.send_request(:example)
+_request, result = request.receive
+puts result # => :hello
+response_request, result = request.receive
+puts result # => :world
+response_request.send(:inner)
+```
+
+The method `receive_request` will only receive a `Request` that was sent with `send_request` and thus is not a response to another `Request`.
+
+The method `Request#receive` will only receive a `Request` that is a direct response to the receiver.
+
+#### Implementation
+
+`send_request` / `receive_request` use `Ractor#send` and `Ractor#receive_if` with the following layout:
+
+```ruby
+message = [Request, ...]
+```
+
+To avoid interfering with `Request`, any other Ractor communication must use `receive_if` and filter out messages of that form (i.e. any array starting with an instance of `Request`).
+
+### Mid-level API: `Talk` using `sync:`
+
+One may specify the expected syncing for a `Request`:
+
+* `:tell`: receiver may not reply ("do this, I'm assuming it will get done")
+* `:ask`: receiver must reply exactly once with sync type `:conclude`  ("do this, let me know when done, and don't me ask questions")
+* `:conclude`: as with `:tell`, receiver may not reply. Must be in response of `ask` or `converse`
+* `:converse`: receiver may reply has many times as desired (with sync type `:tell`, `:ask`, or `:converse`) and must then reply exactly once with sync type `:conclude`.  ("do this, ask questions if need be, and let me know when done")
+
+The API uses `send_request`/`send` with a `sync:` named argument:
+
+```ruby
+ractor = Ractor.new do
+  request, data = receive_request
+  puts data # => :example
+  request.send(:hello, sync: :tell)
+  response_request = request.send(:world, sync: :ask)
+  other_request, data = response_request.receive
+  puts data # => :inner
+  # ...
+end
+
+request = ractor.send_request(:example, sync: :converse)
+response_request, result = request.receive
+puts result # => :hello
+puts response_request.sync # => :tell
+response_request.send(:whatever, sync: :conclude) # => Error "can not reply to sync: say"
+response_request, result = request.receive
+puts result # => :world
+request.receive # => Error, "request must be replied to"
+response_request.send(:inner, sync: :conclude)
+```
+
+This example achieves exactly the same as before, but with clear semantics and checking on the sequence of events.
+
+Shortcuts exists:
+
+```ruby
+ractor.send_request(..., sync: :tell) # or :ask, :conclude or :converse
+# shortcuts:
+ractor.tell(...)  # or .ask(...), .conclude(...) or .converse(...)
+
+# Similarly for `Request#send`:
+request.send(..., sync: :tell)
+# same as
+request.tell(...)
+# etc.
+```
+
+### High-level API: `Client` & `Server`
+
+The `Client` and `Server` module make it easy to use the `sync:` API to allow a client to call methods on the server and for the server to yield back to the client.
+
+The client makes a method call using either `:tell` or `:ask` and the data consists of the method name, arguments and keyword parameters.
+The result is either the request (`:tell`) or the data received (`:ask`).
+
+For method calls with blocks, the client uses `:converse`. The server may yield back to the client with a nested `:converse` response. From inside the block, the client can send nested calls to the server (simple or with block). The result of the block is returned to the server with `:conclude`. The server may then yield again, or if it is finished it `conclude`s the outer conversation.
+
+To define a server, it suffices to define the methods that may be called normally and use `yield` if desired.
+
+All public methods are assumed to be callable from a client with `:ask`, except setters that are assumed to be called with `:tell`.
+
+Here is a complete example of how to define a `Server` that can hold a value:
+
+```ruby
+class SharedObject < Ractor::Client
+  class Server
+    include Ractor::Server
+
+    attr_accessor :value
+
+    def initialize(value = nil)
+      @value = value
+    end
+
+    def update
+      @value = yield @value
+    end
+  end
+end
+
+LIST = ShareObject.new([1, 2])
+
+Ractor.new do
+  LIST.value # => [1, 2]
+  LIST.value = [:changed]
+end.take
+
+LIST.value # => [:changed]
+LIST.update do |cur|
+  cur << :extra
+end
+LIST.value # => [:changed, :extra]
+```
+
+Note that `update` in the example above is atomic; if another Ractor calls `LIST.<anything>`, that request will wait until the `update` is completed. Nevertheless, calls issued from *inside* the `update` block will be processed synchroneously.
+
+#### Defining classes
+
+To create a `Server` class:
+
+```ruby
+class MyServer
+  include Ractor::Server
+
+  # define your methods...
+end
+```
+
+This adds a few methods (`#main_loop`, `#receive_request` and `#process_request`)
+as well as class methods `tells` (private).
+
+This automatically defines a `Client` class and a `Client::ServerCallLayer` module; these may be subclassed/included if desired:
+
+```ruby
+class MyClient < MyServer::Client
+
+  # special handling (if needed)
+end
+```
+
+Note that subclass defines a method `initialize(...)` that:
+* starts the server
+* make itself shareable
+
+An equivalent way to declare a Client is:
+
+```ruby
+class MyClient < Ractor::Client
+  include MyServer::Client::ServerCallLayer
+
+  # special handling (if needed)
+end
+```
+
+#### Customizing the client
+
+It may be necessary to customize the `Client` interface.
+
+For example in the `SharedObject` example above, it may be more efficient if the shared object is always shareable. This can be done by customizing the client:
+
+```ruby
+class SharedObject
+  # ... as above
+
+  class Client # refine the client interface:
+    def initialize(value = nil)
+      Ractor.make_shareable(value)
+      super
+    end
+
+    def update
+      super { Ractor.make_shareable(yield) }
+    end
+  end
+end
+```
+
+In this case, the `update` block above would raise a `FrozenError` and must be modified to a non-mutating form:
+
+```ruby
+LIST.update do |cur|
+  cur + [:extra]
+end
+```
+
+#### Customizing the sync
+
+If we wanted to add a method `clear` to our server, there is no real need for the client to wait for the response as the result will not be useful. To specify that the method should be called with `:tell` instead of `:ask`, one may call `tells :clear`, or use the fact that `def` returns the method it defined:
+
+```ruby
+class SharedObject
+  # ...
+
+  tells def clear
+    @value = nil
+  end
+end
+```
+
+## To do
+
+* Exception rescuing and propagation
+* API to pass block via makeshareable
+* Monitoring
+* Promise-style communication
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ractor-server'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install ractor-server
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marcandre/ractor-server. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/marcandre/ractor-server/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Ractor::Server project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/marcandre/ractor-server/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'ractor/server'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ractor/server/client.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+require_relative 'server'
+
+class Ractor
+  module Server
+    class Client
+      include Debugging
+      attr_reader :server
+
+      def initialize(server)
+        raise ArgumentError, "Expected a Ractor, got #{server.inspect}" unless server.is_a?(::Ractor)
+
+        @nest_request_key = :"Ractor::Server::Client#{object_id}"
+        @server = server
+        freeze
+      end
+
+      CONFIG = {
+        share_args: Set[].freeze,
+        tell_methods: Set[].freeze,
+      }
+
+      def inspect
+        "<##{self.class} server: #{call_server(:inspect)}>"
+      end
+
+      alias_method :to_s, :inspect
+
+      NOT_IMPLICITLY_DEFINED = (Object.instance_methods | Ractor::Server.instance_methods).freeze
+      private_constant :NOT_IMPLICITLY_DEFINED
+
+      class << self
+        include Debugging
+
+        def start(*args, **options)
+          ractor = self.class::Server.start_ractor(*args, **options)
+          new(ractor)
+        end
+
+        def refresh_server_call_layer
+          layer = self::ServerCallLayer
+          server_klass = self::Server
+          are_defined = layer.instance_methods
+          should_be_defined = server_klass.instance_methods - NOT_IMPLICITLY_DEFINED
+          (are_defined - should_be_defined).each { layer.remove_method _1 }
+          interface_with_server(*config(:tell_methods) | should_be_defined - are_defined)
+        end
+
+        def interface_with_server(*methods)
+          methods.flatten!(1)
+          self::ServerCallLayer.class_eval do
+            methods.each do |method|
+              public alias_method(method, :call_server_alias)
+            end
+          end
+          debug(:interface) { "Defined methods #{methods.join(', ')}" }
+
+          methods
+        end
+
+        def tells(*methods)
+          methods.flatten!(1)
+          config(:tell_methods) { |set| set + methods }
+          interface_with_server(*methods)
+        end
+
+        def config(key)
+          cur = self::CONFIG
+          cur_value = cur.fetch(key)
+          if block_given?
+            cur_value = yield cur_value
+            remove_const(:CONFIG) if const_defined?(:CONFIG, false)
+            const_set(:CONFIG, Ractor.make_shareable(cur.merge(key => cur_value)))
+          end
+          cur_value
+        end
+
+        def sync_kind(method, block_given)
+          case
+          when setter?(method) || config(:tell_methods).include?(method)
+            :tell
+          when block_given
+            :converse
+          else
+            :ask
+          end
+        end
+
+        def share_args(*methods)
+          methods.flatten!(1)
+          config(:share_args) { |val| val + methods }
+
+          methods
+        end
+
+        private def inherited(base)
+          mod = Module.new do
+            private def call_server_alias(*args, **options, &block)
+              call_server(__callee__, *args, **options, &block)
+            end
+          end
+
+          base.const_set(:ServerCallLayer, mod)
+          base.include mod
+
+          super
+        end
+
+        NON_SETTERS = Set[*%i[<= == === != >=]].freeze
+        private_constant :NON_SETTERS
+
+        private def setter?(method)
+          method.end_with?('=') && !NON_SETTERS.include?(method)
+        end
+      end
+
+      private def respond_to_missing?(method, priv = false)
+        !priv && implemented_by_server?(method) || super
+      end
+
+      private def method_missing(method, *args, **options, &block)
+        if implemented_by_server?(method)
+          refresh_server_call_layer
+          # sanity check
+          unless self.class::ServerCallLayer.method_defined?(method)
+            raise "`refresh_server_call_layer` failed for #{method}"
+          end
+
+          return __send__(method, *args, **options, &block)
+        end
+
+        super
+      end
+
+      private def implemented_by_server?(method)
+        self.class::Server.method_defined?(method)
+      end
+
+      private def refresh_server_call_layer
+        self.class.refresh_server_call_layer
+      end
+
+      # @returns [Request] if method should be called as `:tell`,
+      # otherwise returns the result of the concluded method call.
+      private def call_server(method, *args, **options, &block)
+        Ractor.make_shareable([args, options]) if share_inputs?(method)
+
+        info = format_call(method, *args, **options, &block) if $DEBUG
+        rq = Request.send(
+          @server, method, args, options,
+          response_to: Thread.current[@nest_request_key],
+          sync: self.class.sync_kind(method, !!block),
+          info: info,
+        )
+        return rq if rq.tell?
+
+        await_response(rq, method, &block)
+      end
+
+      private def await_response(rq, method)
+        debug(:await) { "Awaiting response to #{rq}" }
+
+        loop do
+          response, result = rq.receive
+          case response.sync
+          in :converse
+            block_result = with_requests_nested(response) { yield(result) }
+            Ractor.make_shareable(block_result) if share_inputs?(method)
+            response.conclude block_result
+          in :conclude
+            return result
+          end
+        end
+      ensure
+        debug(:await) { "Finished waiting for #{rq}" }
+      end
+
+      private def with_requests_nested(context)
+        store = Thread.current
+        prev = store[@nest_request_key]
+        store[@nest_request_key] = context
+        yield
+      ensure
+        store[@nest_request_key] = prev
+      end
+
+      private def share_inputs?(method_name)
+        self.class.config(:share_args).include?(method_name)
+      end
+
+      private def format_call(method, *args, **options, &block)
+        args = args.map(&:inspect) + options.map { _1.map(&:inspect).join(': ') }
+        arg_list = "(#{args.join(', ')})" unless args.empty?
+        block_sig = ' {...}' if block
+        "#{method}#{arg_list}#{block_sig}"
+      end
+    end
+  end
+end

data/lib/ractor/server/debugging.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+class Ractor
+  module Server
+    module Debugging
+      def debug(_kind)
+        puts yield if $DEBUG
+      end
+    end
+  end
+end

data/lib/ractor/server/error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+class Ractor
+  module Server
+    class Error < RuntimeError
+    end
+  end
+end

data/lib/ractor/server/request.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+using Ractor::Server::Talk
+
+class Ractor
+  module Server
+    class Request
+      include Debugging
+      attr_reader :response_to, :initiating_ractor, :sync, :info
+
+      def initialize(response_to: nil, sync: nil, info: nil)
+        @response_to = response_to
+        @initiating_ractor = Ractor.current
+        @sync = sync
+        @info = info # for display only
+        enforce_valid_sync!
+        Ractor.make_shareable(self)
+      end
+
+      # Match any request that is a response to the receiver (or an array message starting with such)
+      def ===(message)
+        request, = message
+
+        match = request.is_a?(Request) && self == request.response_to
+
+        debug(:receive) { "Request #{request.inspect} does not match #{self}" } unless match
+
+        match
+      end
+
+      def to_proc
+        method(:===).to_proc
+      end
+
+      # @return [Request]
+      def send(*args, **options)
+        Request.send(initiating_ractor, *args, **options, response_to: self)
+      end
+
+      %i[tell ask converse conclude].each do |sync|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{sync}(*args, **options)                # def tell(*args, **options)
+            send(*args, **options, sync: :#{sync})     #   send(*args, **options, sync: :tell)
+          end                                          # end
+
+          def #{sync}?                                 # def tell?
+            sync == :#{sync}                           #   sync == :tell
+          end                                          # end
+        RUBY
+      end
+
+      def receive
+        enforce_sync_when_receiving!
+        Request.receive_if(&self)
+      end
+
+      def inspect
+        [
+          '<Request',
+          info,
+          ("for: #{response_to}" if response_to),
+          ("sync: #{sync}" if sync),
+          "from: #{ractor_name(initiating_ractor)}>",
+        ].compact.join(' ')
+      end
+      alias_method :to_s, :inspect
+
+      def respond_to_ractor
+        response_to.initiating_ractor
+      end
+
+      class << self
+        include Debugging
+
+        def message(*args, **options)
+          request = new(**options)
+          [request, *args].freeze
+        end
+
+        def pending_send_conclusion
+          ::Ractor.current[:ractor_server_request_send_conclusion] ||= ::ObjectSpace::WeakMap.new
+        end
+
+        def pending_receive_conclusion
+          ::Ractor.current[:ractor_server_request_receive_conclusion] ||= ::ObjectSpace::WeakMap.new
+        end
+
+        def receive_if(&block)
+          message = ::Ractor.receive_if(&block)
+          rq, = message
+          rq.sync_after_receiving
+          debug(:receive) { "Received #{message}" }
+          message
+        end
+
+        def send(ractor, *arguments, move: false, **options)
+          message = Request.message(*arguments, **options)
+          request, = message
+          request.enforce_sync_when_sending!
+          debug(:send) { "Sending #{message}" }
+          ractor.send(message, move: move)
+          request
+        end
+
+        %i[tell ask converse conclude].each do |sync|
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{sync}(r, *args, **options)             # def tell(r, *args, **options)
+              send(r, *args, **options, sync: :#{sync})  #   send(r, *args, **options, sync: :tell)
+            end                                          # end
+          RUBY
+        end
+      end
+
+      # @api private
+      def enforce_sync_when_sending!
+        # Only dynamic checks are done here; static validity checked in constructor
+        case sync
+        when :conclude
+          registry = Request.pending_send_conclusion
+          raise Talk::Error, "Request #{response_to} already answered" unless registry[response_to]
+
+          registry[response_to] = false
+        when :ask, :converse
+          Request.pending_receive_conclusion[self] = true
+        end
+      end
+
+      # @api private
+      def sync_after_receiving
+        # Only dynamic checks are done here; static validity checked in constructor
+        case sync
+        when :conclude
+          Request.pending_receive_conclusion[response_to] = false
+        when :ask, :converse
+          Request.pending_send_conclusion[self] = true
+        end
+      end
+
+      # Receiver is request to receive a reply from
+      private def enforce_sync_when_receiving!
+        case sync
+        when :tell, :conclude
+          raise Talk::Error, "Can not receive from a Request for a `#{sync}` sync: #{self}"
+        when :ask, :converse
+          return :ok if Request.pending_receive_conclusion[self]
+
+          raise Talk::Error, "Can not receive as #{self} is already answered"
+        end
+      end
+
+      private def ractor_name(ractor)
+        ractor.name || "##{ractor.to_s.match(/#(\d+) /)[1]}"
+      end
+
+      private def enforce_valid_sync!
+        case [response_to&.sync, sync]
+        in [nil, nil]
+          :ok_unsynchronized
+        in [nil | :converse, :tell | :ask | :converse]
+          :ok_talk
+        in [:ask | :converse, :conclude]
+          :ok_concluding
+        in [:tell | :conclude => from, _]
+          raise Talk::Error, "Can not respond to a Request with `#{from.inspect}` sync"
+        in [:ask, _]
+          raise Talk::Error, "Request with `ask` sync must be responded with a `conclude` sync, got #{sync.inspect}"
+        in [_, nil]
+          raise Talk::Error, "Specify sync to respond to a Request with #{sync.inspect}"
+        else
+          raise ArgumentError, "Unrecognized sync: #{sync.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/ractor/server/server.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+class Ractor
+  module Server
+    include Debugging
+    include Talk
+
+    private def main_loop
+      debug(:server) { "Running #{inspect}" }
+
+      loop do
+        process(*receive_request)
+      end
+
+      debug(:server) { "Terminated #{inspect}" }
+      :done
+    end
+
+    private def process(rq, method_name, args, options, block = nil)
+      if rq.converse?
+        public_send(method_name, *args, **options) do |yield_arg|
+          yield_client(rq, yield_arg)
+        end
+      else
+        public_send(method_name, *args, **options, &block)
+      end => result
+
+      rq.conclude(result) unless rq.tell?
+    end
+
+    private def yield_client(rq, arg)
+      yield_request = rq.converse(arg)
+      loop do
+        rq, *data = yield_request.receive
+        return data.first if rq.conclude?
+
+        # Reentrant request
+        process(rq, *data)
+      end
+    end
+
+    module ClassMethods
+      def tells(*methods)
+        self::Client.tells(*methods)
+      end
+
+      def share_args(*methods)
+        self::Client.share_args(*methods)
+      end
+
+      def start(*args, **options)
+        ractor = start_ractor(*args, **options)
+        self::Client.new(ractor)
+      end
+
+      # @returns [Ractor] running an instance of the Server
+      def start_ractor(*args, **options)
+        ::Ractor.new(self, args.freeze, options.freeze) do |klass, args, options|
+          server = klass.new(*args, **options)
+          server.__send__ :main_loop
+        end
+      end
+    end
+
+    class << self
+      private def included(base)
+        base.const_set(:Client, ::Class.new(Client) { const_set(:Server, base) })
+        base.extend ClassMethods
+      end
+    end
+  end
+end

data/lib/ractor/server/talk.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+module RefinementExporter
+  refine Module do
+    # See https://bugs.ruby-lang.org/issues/17374#note-8
+    def refine(what, export: false)
+      mod = super(what)
+      return mod unless export
+
+      export = self if export == true
+      export.class_eval do
+        mod.instance_methods(false).each do |method|
+          define_method(method, mod.instance_method(method))
+        end
+        mod.private_instance_methods(false).each do |method|
+          private define_method(method, mod.instance_method(method))
+        end
+      end
+      mod
+    end
+  end
+end
+using RefinementExporter
+
+class Ractor
+  module Server
+    module Talk
+      class Error < Server::Error
+      end
+
+      class << self
+        def receive_request
+          Request.receive_if { |rq,| rq.is_a?(Request) }
+        end
+      end
+
+      refine ::Ractor, export: true do
+        include Debugging
+
+        # @return [Request]
+        private def receive_request
+          Talk.receive_request
+        end
+
+        # @return [Request]
+        def send_request(*arguments, **options)
+          Request.send(self, *arguments, **options)
+        end
+      end
+
+      refine ::Ractor.singleton_class do
+        def receive_request
+          Talk.receive_request
+        end
+      end
+    end
+  end
+end

data/lib/ractor/server/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+class Ractor
+  module Server
+    VERSION = '0.1.1'
+  end
+end

data/lib/ractor/server.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+require 'require_relative_dir'
+require 'set'
+
+using RequireRelativeDir
+require_relative_dir first: %i[debugging error talk]

data/ractor-server.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'lib/ractor/server/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ractor-server'
+  spec.version       = Ractor::Server::VERSION
+  spec.authors       = ['Marc-Andre Lafortune']
+  spec.email         = ['github@marc-andre.ca']
+
+  spec.summary       = 'Ractor based communication inspired by GenServer.'
+  spec.description   = 'Ractor based communication inspired by GenServer.'
+  spec.homepage      = 'https://github.com/ractor-tools/ractor-server'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 3.0.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/ractor-tools/ractor-server'
+  # spec.metadata["changelog_uri"] = "https://github.com/ractor-tools/ractor-server"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency 'require_relative_dir', '>= 1.1.0'
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: ractor-server
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Marc-Andre Lafortune
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: require_relative_dir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+description: Ractor based communication inspired by GenServer.
+email:
+- github@marc-andre.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".pryrc"
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/ractor/server.rb
+- lib/ractor/server/client.rb
+- lib/ractor/server/debugging.rb
+- lib/ractor/server/error.rb
+- lib/ractor/server/request.rb
+- lib/ractor/server/server.rb
+- lib/ractor/server/talk.rb
+- lib/ractor/server/version.rb
+- ractor-server.gemspec
+homepage: https://github.com/ractor-tools/ractor-server
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ractor-tools/ractor-server
+  source_code_uri: https://github.com/ractor-tools/ractor-server
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Ractor based communication inspired by GenServer.
+test_files: []