farce 0.4.1-java → 0.6.0-java

data/lib/farce/subscription/definitions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  class Subscription
+    Farce.on_main do
+      ractors = Internal.native_ractors? ? [::Ractor] : [Internal::FakeRactor::Main, Internal::FakeRactor::NotMain]
+
+      define(Internal::BasePort, *ractors)      { subscriber.send(it)      }
+      define(Abstract::Publisher)               { subscriber.publish(it)   }
+      define(Abstract::Queue)                   { subscriber.try_push(it)  }
+      define(Internal::Counter, Local::Counter) { |_| subscriber.increment }
+      define(Internal::Flag, Local::Flag)       { |_| subscriber.set       }
+      define(Abstract::Atom)                    { subscriber.value = it    }
+      define(Abstract::Set, Abstract::Vector)   { subscriber << it         }
+      define(Signal)                            { |_| subscriber.broadcast }
+
+      define(::Thread::Queue) { subscriber.push(it) }
+      define(::Thread::SizedQueue) do |payload|
+        subscriber.push(payload, true)
+      rescue ThreadError
+        false
+      end
+    end
+  end
+end

data/lib/farce/subscription.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # A publisher subscription that can be paused or permanently canceled.
+  # Disabling skips new messages. Unsubscribing drains an existing callback queue before stopping it.
+  class Subscription
+    include Internal::Freeze::Unfreezable
+    include Internal::Noncopyable
+
+    # Raised when an operation is attempted on an unsubscribed subscription.
+    UnsubscribedError = Class.new(StandardError)
+
+    REGISTER = ClassMirror.new(self)
+    private_constant :REGISTER
+
+    class << self
+      protected :new
+    end
+
+    # Register delivery behavior for subscriber classes from the main Ractor.
+    # Subclasses inherit the nearest registered delivery method.
+    #
+    # @example
+    #   Farce::Subscription.define(MyInbox) { |payload| subscriber.push(payload) }
+    #
+    # @param classes [Array<Class>] the subscriber classes to support
+    # @yieldparam payload [BasicObject] the published payload
+    # @yieldreceiver [Subscription] the subscription whose {#subscriber} receives the payload
+    # @note The block must be convertible to a shareable proc.
+    # @return [void]
+    def self.define(*classes, &)
+      raise LocalJumpError, "no block given" unless block_given?
+      definition = Internal.prepare_method_definition(&)
+      classes.each do |klass|
+        REGISTER.define(klass) do
+          define_method(:deliver, definition)
+          private :deliver
+        end
+      end
+    end
+
+    # @api private
+    def self.build(publisher, subscriber, ...)
+      handler = REGISTER[subscriber.class]
+      unless handler.private_method_defined?(:deliver)
+        raise ArgumentError, "Unsupported subscriber type: #{subscriber.class}"
+      end
+      handler.new(publisher, subscriber, ...)
+    end
+
+    # @return [BasicObject] the subscriber associated with this subscription
+    attr_reader :subscriber
+
+    # @return [Farce::Abstract::Publisher] the publisher associated with this subscription
+    attr_reader :publisher
+
+    # @api private
+    attr_reader :key
+
+    # @!visibility private
+    def initialize(publisher, subscriber, map, callback: false, source: nil)
+      # Keep Proc identities alive without making their captured state shareable.
+      @source     = source && Envelope.new(source, mode: :local)
+      @callback   = callback
+      @enabled    = Flag.new(true)
+      @key        = (source || subscriber).__id__
+      @map        = map
+      @publisher  = publisher
+      @subscribed = Flag.new(true)
+      @subscriber = subscriber
+      super()
+      __freeze__
+    end
+
+    # @api private
+    def publish(payload)
+      return unless enabled?
+      deliver(payload)
+      true
+    rescue ::ClosedQueueError, Ractor::ClosedError, FrozenError
+      unsubscribe
+      false
+    end
+
+    # @return [Boolean] whether the subscription is currently enabled
+    def enabled? = @subscribed.value && @enabled.value
+
+    # @return [Boolean] whether the subscription has not been permanently canceled
+    def subscribed? = @subscribed.value
+
+    # Enables the subscription, allowing it to receive published payloads.
+    # @raise [UnsubscribedError] if the subscription has been unsubscribed
+    # @return [void]
+    def enable
+      raise UnsubscribedError, "Cannot enable a subscription that has been unsubscribed" unless @subscribed.value
+      @enabled.value = true
+    end
+
+    # Disables the subscription, preventing it from receiving published payloads.
+    # @return [void]
+    def disable = @enabled.value = false
+
+    # Removes the subscription permanently, allowing it and the subscriber to be garbage collected.
+    # @return [BasicObject, nil] the subscriber, or nil if already unsubscribed
+    def unsubscribe
+      return unless @subscribed.compare_and_set(true, false)
+      @map.delete_pair(key, self)
+      subscriber.seal if @callback
+      subscriber
+    end
+    alias cancel unsubscribe
+
+    private
+
+    define_method(:__freeze__, Kernel.instance_method(:freeze))
+
+    require "farce/subscription/definitions"
+  end
+end

data/lib/farce/transaction/map.rb

@@ -16,8 +16,42 @@ module Farce
     class Map < Abstract::ConcurrentMap
       include MapOperations
 
+      # (see Abstract::ConcurrentMap#store_if_present)
+      # @param mode [Symbol, nil] The result's transfer mode, or nil to use the default.
+      def store_if_present(key, mode: nil)
+        require_block!(block_given?)
+        write do
+          canonical = prepare(key)
+          next unless @working.key?(canonical)
+          replacement = yield(unwrap_stored(@working[canonical]))
+          unwrap_stored(store_value(canonical, wrap(replacement, mode:)))
+        end
+      end
+
+      # (see Abstract::ConcurrentMap#replace_if_exists)
+      # @param mode [Symbol, nil] The replacement's transfer mode, or nil to use the default.
+      def replace_if_exists(key, replacement, mode: nil)
+        write do
+          canonical = prepare(key)
+          next unless @working.key?(canonical)
+          previous = @working[canonical]
+          store_value(canonical, wrap(replacement, mode:))
+          unwrap_stored(previous)
+        end
+      end
+
+      # (see Abstract::ConcurrentMap#delete_pair)
+      # A failed comparison invalidates the transaction attempt.
+      def delete_pair(key, expected)
+        removed = modify_entry(key) do |present, value|
+          present && values_equal?(value, expected) ? Internal::MAP_DELETE : Internal::MAP_KEEP
+        end
+        compared(removed)
+      end
+
       Wrapper.inherit(self, *MapOperations::READ_HELPERS, :delete_if, :reject!, :compact!, :keep_if,
-        :select!, :filter!, :transform_values!, :merge!)
+        :select!, :filter!, :transform_values!, :merge!, :put, :get_and_set, :compute_if_absent,
+        :compute_if_present, :replace_pair, :compute, :merge_pair, :fetch_or_store, :put_if_absent)
 
       private def enlist(backend) = @transaction.enlist(backend, per_key: true)
     end

data/lib/farce/unshared/pool.rb

@@ -36,7 +36,7 @@ module Farce
         Internal::LocalScheduledTask.new(args, block)
       end
 
-      def schedule_scaler(started, delay = @grow_after)
+      def schedule_scaler(started, delay = settings.grow_after)
         Internal::ThreadPoolSupervisor.current.schedule(self, started, delay)
       end
     end

data/lib/farce/unshared/publisher.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Unshared
+    # Unshared variant of {Farce::Publisher}.
+    class Publisher < Abstract::Publisher
+      include Unshareable
+
+      # @overload initialize(*subscribers)
+      #   (see Farce::Abstract#initialize)
+      def initialize(...)
+        @map = Unshared::Map.new
+        super
+      end
+
+      private
+
+      attr_reader :map
+
+      def default_mode = :local
+    end
+  end
+end

data/lib/farce/unshared/scheduler.rb

@@ -20,12 +20,12 @@ module Farce
     #   results.pop # => :done
     #   scheduler.close
     #
-    # @!method schedule(*args, mode: :smart, auto_local: true)
+    # @!method schedule(*args, mode: :smart, auto_local: true, timeout: nil)
     #   Enqueue a task while retaining its block and argument references.
     #   `mode` is ignored when `auto_local` is true. Otherwise, only local and
     #   smart modes are accepted.
     #   @param (see Farce::Abstract::Executor#schedule)
-    #   @return [self]
+    #   @return [self, nil] self when submitted, or nil when the scheduling timeout expires.
     class Scheduler < Abstract::Scheduler
       include Unshareable
       include Internal::LocalExecutorMethods
@@ -80,7 +80,7 @@ module Farce
       def new_queue(capacity:)             = Internal::UnsharedQueue.new(capacity:)
       def launch_callback                  = ->(_scheduler, priority, name) { launch!(name, priority) }
 
-      def prepare_task(args, block, mode, auto_local)
+      def prepare_task(args, block, mode, auto_local, **)
         validate_local_mode(mode, auto_local)
         Internal::LocalScheduledTask.new(args, block)
       end

data/lib/farce/unshared/vector.rb

@@ -9,10 +9,11 @@ module Farce
       include Unshareable
       include Internal::Freeze::Delegated
 
-      # @param source [Array, nil] Initial values. Values are retained directly.
+      # @param source [Array, Integer, nil] Initial values or a size filled with nil. Values are retained directly.
       # @param compare_by_identity [Boolean] Whether values are compared by identity.
+      # @raise [ArgumentError] If the size is negative.
       def initialize(source = nil, compare_by_identity: false)
-        @vector = Internal::UnsharedVector.new(source, compare_by_identity:)
+        @vector = Internal::UnsharedVector.new(normalize_vector_source(source), compare_by_identity:)
         super()
       end
 

data/lib/farce/vector.rb

@@ -20,18 +20,21 @@ module Farce
     include Shareable::Delegated
 
     # @!macro modes
-    # @param source [Array, nil] Initial values. The source array is not retained.
+    # @param source [Array, Integer, nil] Initial values or a size filled with nil. The source array is not retained.
     # @param mode [Symbol] The default value transfer mode.
     # @param compare_by_identity [Boolean] Whether values are compared by identity.
+    # @raise [ArgumentError] If the size is negative.
     def initialize(source = nil, mode: :smart, compare_by_identity: false)
-      raise TypeError, "source must be an Array" unless source.nil? || source.is_a?(Array)
-      unless true.equal?(compare_by_identity) || false.equal?(compare_by_identity)
-        raise ArgumentError, "compare_by_identity must be true or false"
-      end
+      source = normalize_vector_source(source)
+      raise TypeError, "source must be an Array" unless source.nil? || Integer === source || source.is_a?(Array)
 
-      @compare_by_identity = compare_by_identity
+      @compare_by_identity = compare_by_identity ? true : false
       @manager = ModeManager.new(mode:)
-      @vector = Internal::Vector.new(source&.map { @manager.wrap(it) }, compare_by_identity: true)
+      if source && !(Integer === source)
+        source = source.map { @manager.wrap(it) }
+        raise TypeError, "source must be an Array" unless source.nil? || source.is_a?(Array)
+      end
+      @vector = Internal::Vector.new_for_modes(source)
       super()
     end
 
@@ -51,7 +54,7 @@ module Farce
     def marshal_load(data)
       entries, @manager, identity, frozen = Internal::MarshalSupport.payload(data, 4)
       @compare_by_identity = identity
-      @vector = Internal::Vector.new(compare_by_identity: true)
+      @vector = Internal::Vector.new_for_modes(nil)
       publish_shareable
       entries.each { @vector.push(Internal::MarshalSupport.restore_value(it)) }
       Internal::MarshalSupport.freeze(self, frozen)
@@ -176,11 +179,18 @@ module Farce
           replacement = @manager.wrap(replacement, mode:)
           wrapped = true
         end
-        return true if @vector.compare_and_set(index, current, replacement, timeout: remaining_timeout(deadline))
+        return true if @vector.compare_and_set(index, current, replacement, timeout: Clock.remaining(deadline))
         return false if nil.equal?(current) || (deadline && Clock.now >= deadline)
       end
     end
 
+    # (see Farce::Abstract::Vector#wait_until)
+    def wait_until(index, timeout: nil)
+      raise LocalJumpError, "no block given" unless block_given?
+      result = Internal.wait_until(@vector, index, timeout:) { |current| yield(@manager.unwrap(current)) }
+      @manager.unwrap(result)
+    end
+
     # (see Farce::Abstract::Vector#wait_until_changed)
     def wait_until_changed(index, expected, timeout: nil)
       deadline = timeout_deadline(timeout)
@@ -189,7 +199,7 @@ module Farce
         current = @vector[index]
         return @manager.unwrap(current) unless values_equal?(current, expected)
         return if deadline && Clock.now >= deadline
-        @vector.wait_until_changed(index, current, timeout: remaining_timeout(deadline))
+        @vector.wait_until_changed(index, current, timeout: Clock.remaining(deadline))
       end
     end
 
@@ -243,11 +253,5 @@ module Farce
       raise ArgumentError, "timeout must be finite and non-negative" unless timeout.finite? && !timeout.negative?
       Clock.now + timeout
     end
-
-    def remaining_timeout(deadline)
-      return unless deadline
-      remaining = deadline - Clock.now
-      remaining.negative? ? 0 : remaining
-    end
   end
 end

data/lib/farce/version.rb

@@ -4,5 +4,5 @@
 
 module Farce
   # @return [String] the current version of Farce
-  VERSION = "0.4.1"
+  VERSION = "0.6.0"
 end

data/lib/farce/walker/definitions.rb

@@ -118,8 +118,19 @@ module Farce
           if !key.equal?(new_key)
             entries << [key, new_key, result]
           elsif !value.equal?(result)
-            until target.compare_and_set(key, value, result)
-              value = target[key]
+            loop do
+              retry_update = false
+              send_to(target, :modify_entry, key, canonical: true) do |present, current|
+                next Internal::MAP_KEEP unless present
+                if Internal.value_changed?(current, value, true)
+                  value = current
+                  retry_update = true
+                  next Internal::MAP_KEEP
+                end
+                result
+              end
+              break unless retry_update
+              # Traverse replacements after releasing the key's update reservation.
               result = walker.visit(value)
             end
           end
@@ -179,6 +190,24 @@ module Farce
       super(object, walker)
     end
 
+    define(Struct) do |object, walker|
+      result = walker.update(object, object.to_a) do |target, results|
+        results.each_with_index { |value, index| target[index] = value unless target[index].equal?(value) }
+        target
+      end
+      super(result, walker)
+    end
+
+    define(Range) do |object, walker|
+      names = object.instance_variables
+      values = [object.begin, object.end, *names.map { object.instance_variable_get(it) }]
+      walker.update(object, values) do |target, results|
+        names.each_with_index { |name, index| target.instance_variable_set(name, results[index + 2]) }
+        Internal.initialize_range(target, results[0], results[1], object.exclude_end?)
+        target
+      end
+    end
+
     define(Data) do |object, walker|
       walker.rebuild_data(object)
     end

data/lib/farce/walker/modification.rb

@@ -172,14 +172,14 @@ module Farce
         node ? node.changed == true : (@seen.key?(object) && !@seen[object].equal?(object))
       end
 
-      # Follow pending references to check that hashing cannot reach unfinished Data.
+      # Follow pending references to check that hashing cannot reach unfinished values.
       def hashable?(object)
-        return true unless @unfinished_data && !@unfinished_data.empty?
+        return true unless @unfinished_values && !@unfinished_values.empty?
         !Walker.visit(object, constants:, class_variables:) do |value, traversal|
-          traversal.return(true) if @unfinished_data.key?(value)
+          traversal.return(true) if @unfinished_values.key?(value)
           node = @nodes[value] || @destinations&.[](value)
           if node && node.plans
-            traversal.return(true) if @unfinished_data.key?(node.destination)
+            traversal.return(true) if @unfinished_values.key?(node.destination)
             node.plans.each { |plan| plan.children.each { traversal.visit(resolved(it)) } }
           else
             traversal.traverse
@@ -188,10 +188,10 @@ module Farce
         end
       end
 
-      # Reject keys and set elements whose Data dependencies are still being built.
+      # Reject keys and set elements whose immutable dependencies are still being built.
       def check_hash_key(object)
         return object if hashable?(object)
-        raise ArgumentError, "hash key or set element refers to an unfinished Data value"
+        raise ArgumentError, "hash key or set element refers to an unfinished Data or Range value"
       end
 
       private
@@ -217,19 +217,19 @@ module Farce
           dirty        ||= plan.hash_keys && (index % plan.key_stride).zero? && child && child.changed
         end
         node.changed ||= dirty
-        plan.dirty = dirty
+        plan.dirty = dirty || (Range === node.destination && @unfinished_values&.key?(node.destination))
       end
 
-      # Choose a writable destination, copying lazily or allocating unfinished Data.
+      # Choose a writable destination, copying lazily or allocating unfinished values.
       def prepare(node, rebuild: false)
         previous = node.destination
         return previous unless rebuild || previous.equal?(node.original)
         object = node.original
         return object if Internal::Noncopyable === object || Abstract::LeaseMap === object
         destination =
-          if Data === object
+          if Data === object || Range === object
             value = object.class.allocate
-            (@unfinished_data ||= {}.compare_by_identity)[value] = true
+            (@unfinished_values ||= {}.compare_by_identity)[value] = true
             value
           elsif @modify == true
             send_to(object, :frozen?) ? send_to(object, :clone, freeze: false) : object
@@ -241,6 +241,7 @@ module Farce
         (@destinations ||= {}.compare_by_identity)[destination] = node unless destination.equal?(object)
         node.destination = destination
         node.result = destination if !node.skipped && (node.result.equal?(object) || node.result.equal?(previous))
+        node.plans&.each { it.dirty = true } if Range === destination
         destination
       end
 
@@ -259,7 +260,7 @@ module Farce
           node.destination = result
           node.result = result if node.result.equal?(old)
         end
-        @unfinished_data&.delete(node.destination) if Data === node.destination
+        @unfinished_values&.delete(node.destination) if Data === node.destination || Range === node.destination
         return unless node.cyclic
         plan.target = node.destination
         plan.applied = plan.results.dup
@@ -281,6 +282,9 @@ module Farce
         if freeze
           node.changed = true unless send_to(node.result, :frozen?)
           prepare(node) if @modify != true && node.result.equal?(node.original) && !send_to(node.result, :frozen?)
+          if Range === node.destination && @unfinished_values&.key?(node.destination)
+            node.plans&.each { apply(node, it) }
+          end
           send_to(node.result, :freeze)
         end
         finalize_node(node) if finalize
@@ -308,15 +312,25 @@ module Farce
               freezing = !node.skipped && (node.freeze_result || @freeze == true)
               needed   = node.plans&.any?(&:dirty) || (freezing && @modify != true && !send_to(node.original, :frozen?))
               prepare(node) if needed
-              next unless Data === node.destination && send_to(node.destination, :frozen?) && node.plans&.any? do |plan|
-                plan.applied && plan.results.each_with_index.any? { |value, index| !value.equal?(plan.applied[index]) }
+              next unless Data === node.destination || Range === node.destination
+              # Rebuild only after this destination's own assignments become stale.
+              next unless node.plans&.any? do |plan|
+                plan.target.equal?(node.destination) && plan.applied &&
+                  plan.results.each_with_index.any? { |value, index| !value.equal?(plan.applied[index]) }
               end
               prepare(node, rebuild: true)
             end
             break if component.each_with_index.all? { |node, index| node.destination.equal?(destinations[index]) }
           end
 
-          component.sort_by { Data === it.destination ? 2 : (it.plans&.any?(&:hash_keys) ? 1 : 0) }.each do |node|
+          ordered = component.sort_by do |node|
+            if Data === node.destination || Range === node.destination
+              2
+            else
+              node.plans&.any?(&:hash_keys) ? 1 : 0
+            end
+          end
+          ordered.each do |node|
             @node           = node
             @current_object = node.original
             node.plans&.each do |plan|

data/lib/farce/walker.rb

@@ -140,14 +140,18 @@ module Farce
     end
 
     # Transform a graph using the callback's return values.
+    #
     # Call {#traverse} to transform an object's children. Returning another value
     # replaces the object without automatically visiting that replacement.
     # Unchanged branches retain their identity, including when copy is enabled.
+    #
     # Changed cycles are connected before results are frozen or finalized.
     # A cyclic callback may run again as child replacements become known. Keep
     # callbacks repeatable and put publication or caching in {#finalize}.
     # Use {#freeze_result} instead of freezing a preliminary traversal result.
+    #
     # Data values are rebuilt only when members change, using their normal initializer.
+    # Ranges are rebuilt when endpoints or instance variables change.
     # Noncopyable coordination objects, such as leases, are updated in place.
     # Constants and class variables are assigned only when their value
     # changes identity. Constant replacement can emit Ruby redefinition warnings.
@@ -156,6 +160,7 @@ module Farce
     #
     # A walk is not an atomic snapshot or update. Coordinate concurrent writers
     # when transforming container structure, especially map keys.
+    #
     # @param object [BasicObject] the root object
     # @!macro walker_module_options
     # @param copy [Boolean, Symbol] false to edit mutable objects in place, true to
@@ -171,7 +176,7 @@ module Farce
     # @raise [ArgumentError] if copy is neither a boolean nor a Symbol
     # @raise [ArgumentError] if cyclic callbacks do not converge within 32 passes,
     #   or a cyclic finalizer replaces its result
-    # @raise [ArgumentError] if a hash key or set element refers to a Data value
+    # @raise [ArgumentError] if a hash key or set element refers to a Data or Range value
     #   still being constructed. Identity-based containers do not hash their keys.
     def self.modify(object, copy: false, freeze: nil, constants: true, class_variables: true, &callback)
       raise LocalJumpError, "no block given" unless callback
@@ -263,9 +268,11 @@ module Farce
     def remember(object, result) = @seen[object] = result
 
     # Visit child values and describe how to assign their replacements.
+    #
     # The assignment block only runs during modification and may run again for cycles.
     # It receives a writable target and the resolved children. Do not mutate object
     # outside this block. Return the result of update from a traversal definition.
+    #
     # @param object [BasicObject] the object being traversed
     # @param values [Array] child references in assignment order
     # @param hash_keys [Boolean] rebuild when key descendants change in place
@@ -288,6 +295,7 @@ module Farce
     # and requested freezing. Registering another finalizer replaces the first.
     # Cyclic finalizers must preserve identity. Acyclic finalizers may return a
     # canonical replacement, which is propagated to the parent.
+    #
     # @yieldparam result [BasicObject] the settled result
     # @yieldparam cyclic [Boolean] whether the node belongs to a cycle
     # @yieldreturn [BasicObject] the final result

data/lib/farce/weak_atom.rb

@@ -100,14 +100,17 @@ module Farce
       matched
     end
 
+    # (see Abstract::Atom#wait_until)
+    def wait_until(timeout: nil, &) = Internal.wait_until(@atom, timeout:, &)
+
     # (see Abstract::Atom#wait_until_changed)
     def wait_until_changed(expected, timeout: nil, &fallback)
       deadline = Internal.timeout_deadline(timeout)
       while true
-        current = @atom.get(timeout: Internal.remaining_timeout(deadline)) { TIMED_OUT }
+        current = @atom.get(timeout: Clock.remaining(deadline)) { TIMED_OUT }
         return fallback&.call if TIMED_OUT.equal?(current)
         return current unless values_equal?(current, expected)
-        result = @atom.wait_until_changed(current, timeout: Internal.remaining_timeout(deadline)) { TIMED_OUT }
+        result = @atom.wait_until_changed(current, timeout: Clock.remaining(deadline)) { TIMED_OUT }
         return fallback&.call if TIMED_OUT.equal?(result)
       end
     end

data/lib/farce/weak_key_map.rb

@@ -23,7 +23,7 @@ module Farce
 
     private
 
-    def new_map(**)    = Internal::StrictWeakKeyMap.new(**)
+    def new_map(...) = Internal::StrictWeakKeyMap.new(...)
     def freeze_backend = @map
   end
 

data/lib/farce/weak_map.rb

@@ -25,7 +25,7 @@ module Farce
 
     private
 
-    def new_map(**)    = Internal::StrictWeakMap.new(**)
+    def new_map(...) = Internal::StrictWeakMap.new(...)
     def freeze_backend = @map
   end
 

data/lib/farce/weak_value_map.rb

@@ -24,7 +24,7 @@ module Farce
 
     private
 
-    def new_map(**)    = Internal::StrictWeakValueMap.new(**)
+    def new_map(...) = Internal::StrictWeakValueMap.new(...)
     def freeze_backend = @map
   end
 

data/lib/farce.rb

@@ -429,7 +429,9 @@ module Farce
   end
 
   # Schedules work without waiting for the block to finish.
-  # On CRuby, uses a shared Ractor pool with at most {System.cpu_count} workers.
+  # On CRuby, uses a shared Ractor pool with at most {System.cpu_count} workers by default.
+  # Set {Config}'s `parallel_pool_*` options before creating a scheduler to configure
+  # its worker limits, growth and shrink delays, per-worker task limit, and queue capacity.
   # On JRuby and TruffleRuby, starts a new thread for each task.
   #
   # Without a block, returns the shared scheduler. The CRuby pool starts workers