farce 0.4.1-java → 0.6.0-java

data/lib/farce/internal/blocking_priority_queue.rb

@@ -32,7 +32,8 @@ module Farce
 
         wait(timeout) do
           raise_unwritable if sealed?
-          size < capacity
+          limit = capacity
+          !limit || size < limit
         end
       end
 
@@ -76,7 +77,7 @@ module Farce
         while true
           return true if internal_queue.push(priority, value)
           raise ThreadError, "queue full" if non_block
-          return false unless wait_push(timeout: remaining_timeout(deadline))
+          return false unless wait_push(timeout: Clock.remaining(deadline))
         end
       end
 
@@ -98,7 +99,7 @@ module Farce
           generation = internal_signal.generation
           raise ::Farce::ClosedQueueError, "queue is closed" if closed?
           return true if yield
-          return false unless internal_signal.wait(generation, timeout: remaining_timeout(deadline))
+          return false unless internal_signal.wait(generation, timeout: Clock.remaining(deadline))
         end
       end
 
@@ -111,12 +112,6 @@ module Farce
       def timeout_at(timeout)
         Clock.timeout(normalize_timeout(timeout)) unless timeout.nil?
       end
-
-      def remaining_timeout(timeout_at)
-        return unless timeout_at
-        timeout = timeout_at - Clock.now
-        timeout.positive? ? timeout : 0
-      end
     end
   end
 end

data/lib/farce/internal/fake_ractor.rb

@@ -61,7 +61,7 @@ module Farce
           STATES[self] = state
           GROUPS[group] = self
 
-          state.main_thread = Thread.new do # rubocop:disable Lint/UselessSetterCall
+          state.main_thread = Thread.new do
             current = Thread.current
             group.add(current)
             current.freeze

data/lib/farce/internal/flag_waiting.rb

@@ -21,7 +21,7 @@ module Farce
           observed = signal.generation
           current = value
           return current unless expected == current
-          break unless signal.wait(observed, timeout: Internal.remaining_timeout(deadline))
+          break unless signal.wait(observed, timeout: Clock.remaining(deadline))
         end
         yield if block_given?
       end

data/lib/farce/internal/freeze.rb

@@ -8,11 +8,7 @@ module Farce
     module Freeze
       # Structurally freeze a Ruby facade, then validate and publish its object graph.
       # This deliberately bypasses an override that controls logical frozen state.
-      def self.publish(object)
-        Object.instance_method(:freeze).bind_call(object)
-        ::Ractor.make_shareable(object) if Internal.native_ractors?
-        object
-      end
+      def self.publish(object) = Internal.publish_shareable(object)
 
       def self.check(object)
         return object unless object.frozen?

data/lib/farce/internal/lease_initialization.rb

@@ -31,7 +31,7 @@ module Farce
             reject_recursive_initialization!
             return unless wait
 
-            remaining = deadline - Clock.now if deadline
+            remaining = Clock.remaining(deadline)
             return if remaining && !remaining.positive?
             reject_unscheduled_fiber_wait!
             @signal.wait(observed, timeout: wait_interval(remaining))

data/lib/farce/internal/lease_pool_state.rb

@@ -108,7 +108,7 @@ module Farce
           return create_resource(factory) if reserve_creation
           return unless wait
 
-          remaining = deadline - Clock.now if deadline
+          remaining = Clock.remaining(deadline)
           raise TimeoutError, "lease pool checkout timed out" if remaining && !remaining.positive?
           interval = LeaseWaiting.wait_interval(remaining)
           changed  = Thread.handle_interrupt(Exception => :immediate) do

data/lib/farce/internal/lease_state.rb

@@ -156,7 +156,7 @@ module Farce
           resource = try_acquire(kind)
           return resource if resource
 
-          remaining = deadline - Clock.now if deadline
+          remaining = Clock.remaining(deadline)
           raise TimeoutError, "lease checkout timed out" if remaining && !remaining.positive?
           reject_unscheduled_fiber_wait!
           interval = wait_interval(remaining)
@@ -180,7 +180,7 @@ module Farce
           outcome  = try_acquire_block(block)
           return outcome.first if outcome
 
-          remaining = deadline - Clock.now if deadline
+          remaining = Clock.remaining(deadline)
           raise TimeoutError, "lease checkout timed out" if remaining && !remaining.positive?
           reject_unscheduled_fiber_wait!
           interval = wait_interval(remaining)

data/lib/farce/internal/local_executor_methods.rb

@@ -16,10 +16,10 @@ module Farce
       # Run a task directly, preserving its block, arguments, and calling fiber.
       # `mode` and `auto_local` follow the same validation as {#schedule}.
       # @param (see Abstract::Executor#execute)
-      # @return [self]
-      def execute(*, mode: :smart, auto_local: true, &)
+      # @return [self, nil]
+      def execute(*, mode: :smart, auto_local: true, timeout: nil, &)
         validate_local_mode(mode, auto_local)
-        super(*, mode: :local, auto_local: true, &)
+        super(*, mode: :local, auto_local: true, timeout:, &)
       end
 
       private

data/lib/farce/internal/map_value_modes.rb

@@ -22,9 +22,7 @@ module Farce
                      compare_keys_by_identity: compare_by_identity, compare_values_by_identity: compare_by_identity)
         initial_mapping = convert_entries(initial_mapping)
 
-        identity         = BasicObject.instance_method(:equal?)
-        valid_comparison = identity.bind_call(compare_values_by_identity, true) ||
-          identity.bind_call(compare_values_by_identity, false)
+        valid_comparison = true.equal?(compare_values_by_identity) || false.equal?(compare_values_by_identity)
 
         raise ArgumentError, "compare_values_by_identity must be a boolean" unless valid_comparison
         @compare_values_by_identity = compare_values_by_identity
@@ -33,9 +31,11 @@ module Farce
         @map     = new_map(compare_by_identity:, compare_keys_by_identity:, compare_values_by_identity: true)
         KeyNormalizer.prepare_concurrent(@map)
 
-        restoring  = KeyNormalizer.restoration?(normalize_keys)
-        normalizer = KeyNormalizer.build(normalize_keys, shareable: true)
-        KeyNormalizer.install_concurrent(self, normalizer) unless restoring
+        unless nil.equal?(normalize_keys)
+          restoring  = KeyNormalizer.restoration?(normalize_keys)
+          normalizer = KeyNormalizer.build(normalize_keys, shareable: true)
+          KeyNormalizer.install_concurrent(self, normalizer) unless restoring
+        end
 
         initial_mapping&.each { |key, value| self[key] = value }
         KeyNormalizer.install_concurrent(self, normalizer) if restoring
@@ -143,18 +143,26 @@ module Farce
         end
       end
 
+      # (see Abstract::ConcurrentMap#wait_until)
+      def wait_until(key, timeout: nil)
+        raise LocalJumpError, "no block given" unless block_given?
+        result = Internal.wait_until(@map, key, timeout:) { |current| yield(unwrap_value(current)) }
+        unwrap_value(result)
+      end
+
       def wait_until_changed(key, expected, timeout: nil, &)
         prepared_key = @map.normalize_external_key(key)
         expected = wrap_comparison(expected)
         deadline = Internal.timeout_deadline(timeout)
-        loop do
-          current = @map.get_prepared(prepared_key, timeout: Internal.remaining_timeout(deadline)) { TIMED_OUT }
+        # JRuby rejects repeated anonymous block forwarding inside a block.
+        while true
+          current = @map.get_prepared(prepared_key, timeout: Clock.remaining(deadline)) { TIMED_OUT }
           return unwrap_result(current, &) if TIMED_OUT.equal?(current)
           return unwrap_value(current) unless values_equal?(nil.equal?(current) ? NIL_VALUE : current, expected)
           result = @map.wait_until_changed_prepared(
             prepared_key,
             current,
-            timeout: Internal.remaining_timeout(deadline),
+            timeout: Clock.remaining(deadline),
           ) { TIMED_OUT }
           return unwrap_result(result, &) if TIMED_OUT.equal?(result)
         end

data/lib/farce/internal/pool_settings.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Internal # :nodoc: all
+    PoolSettings = Data.define(:min_size, :max_size, :max_inflight, :grow_after, :shrink_after, :generation)
+  end
+end

data/lib/farce/internal/pool_worker.rb

@@ -9,46 +9,59 @@ module Farce
       include Shareable::Unfreezable
 
       def initialize(pool)
-        @pool       = pool
-        @inflight   = Counter.new if pool.max_inflight || pool.shrink_after
-        @pressure   = pool.min_size < pool.max_size
+        @pool = pool
+        @inflight = Counter.new
         @registered = Atom.new(true)
         super()
       end
 
-      def idle_timeout = @pool.shrink_after
-
-      def wait_for_admission(scheduler, runnable_count)
-        return false if @pool.drained?
-        limit = @pool.max_inflight
-        return true unless limit
+      def settings = @pool.settings
+      def idle_timeout = settings.shrink_after
 
+      def wait_for_admission(scheduler, runnable_count, settings = self.settings)
         loop do
           return false if @pool.drained?
-          return true if @pool.closing? || @pool.at_max_size? || @inflight.value < limit
-          return true if runnable_count && scheduler.public_send(runnable_count).zero?
+          return settings if @pool.closing?
+          count = @pool.size
+          limit = settings.max_inflight
+          return false if count > settings.max_size && retire?(excess: true)
+          # Busy workers keep queued dependencies runnable until they become idle.
+          return settings if !limit || count >= settings.max_size || @inflight.value < limit
+          return settings if runnable_count && scheduler.public_send(runnable_count).zero?
 
+          # Read the generation before rechecking state to avoid a lost configuration wakeup.
           generation = @pool.admission_generation
-          next if @pool.closing? || @pool.at_max_size? || @inflight.value < limit
+          settings = self.settings
+          count = @pool.size
+          limit = settings.max_inflight
+          next if @pool.closing? || !limit || count >= settings.max_size || @inflight.value < limit
           @pool.wait_for_admission(generation)
+          settings = self.settings
         end
       end
 
-      def task_started
-        @inflight&.increment
-        @pool.task_taken if @pressure
+      def task_started(settings = self.settings)
+        @inflight.increment
+        @pool.task_taken(settings)
       end
 
       def task_finished
-        return unless @inflight
         @inflight.decrement
-        @pool.admission_changed if @pool.max_inflight && !@pool.at_max_size?
+        settings = self.settings
+        count = @pool.size
+        if count > settings.max_size
+          @inflight.value.zero? ? @pool.wake_retiring_workers : @pool.admission_changed
+        elsif settings.max_inflight && count < settings.max_size
+          @pool.admission_changed
+        end
       end
 
-      def retire?
-        return false unless @inflight&.value&.zero?
-        return false unless @pool.retire_worker
-        @registered.compare_and_set(true, false)
+      def retire?(excess: false, expected: nil)
+        return false unless @inflight.value.zero?
+        return false unless @pool.retire_worker(excess:, expected:)
+        retired = @registered.compare_and_set(true, false)
+        @pool.worker_retired if retired
+        retired
       end
 
       def stopped(error, replace: true) # rubocop:disable Naming/PredicateMethod

data/lib/farce/internal/reservation_waiting.rb

@@ -9,7 +9,7 @@ module Farce
     module ReservationWaiting
       def self.wait(signal, generation, deadline)
         while true
-          remaining = deadline - Clock.now if deadline
+          remaining = Clock.remaining(deadline)
           return false if remaining && !remaining.positive?
 
           # LeaseWaiting supplies the full remaining timeout on default engines

data/lib/farce/internal/scheduler_lifecycle.rb

@@ -146,8 +146,8 @@ module Farce
           service_policy
           break if idle?
           deadline = @timers.peek_priority
-          timeout = deadline ? deadline - Clock.now : nil
-          timeout = 0 if timeout&.negative? || ready? || !@mailbox.empty?
+          timeout = Clock.remaining(deadline)
+          timeout = 0 if ready? || !@mailbox.empty?
           dispatch(timeout, @timers.empty? ? @dispatch_budget : 256)
         end
 

data/lib/farce/internal/weak_map_value_modes.rb

@@ -24,6 +24,11 @@ module Farce
         super
       end
 
+      def replace_if_exists(key, replacement, mode: nil, **)
+        @manager.validate_mode!(mode)
+        super
+      end
+
       def store_if_absent(key, mode: nil, **)
         raise LocalJumpError, "no block given" unless block_given?
         @manager.validate_mode!(mode)

data/lib/farce/internal.rb

@@ -77,18 +77,12 @@ module Farce
       Clock.now + timeout
     end
 
-    def remaining_timeout(deadline)
-      return unless deadline
-      remaining = deadline - Clock.now
-      remaining.negative? ? 0 : remaining
-    end
-
     # Repeat with one timeout budget. Even a zero timeout permits the first check.
     def with_timeout(timeout)
       raise LocalJumpError, "no block given" unless block_given?
       deadline = timeout_deadline(timeout)
       loop do
-        yield remaining_timeout(deadline), deadline
+        yield Clock.remaining(deadline), deadline
         return if deadline && Clock.now >= deadline
       end
     end
@@ -98,10 +92,16 @@ module Farce
       with_timeout(timeout) do |_, deadline|
         current = keys.empty? ? receiver.value : receiver[*keys]
         return current if yield(current)
-        receiver.wait_until_changed(*keys, current, timeout: remaining_timeout(deadline)) { return }
+        receiver.wait_until_changed(*keys, current, timeout: Clock.remaining(deadline)) { return }
       end
     end
 
+    # An unchanged observation must permit waiting even when its equality is non-reflexive.
+    def value_changed?(current, expected, identity)
+      return false if BasicObject.instance_method(:equal?).bind_call(current, expected)
+      identity || !(current == expected) # rubocop:disable Style/InverseMethods -- != can be overridden independently.
+    end
+
     def garbage_collectable?(object)
       case object
       when Integer, Float, Complex, Rational, Symbol, true, false, nil then false
@@ -113,9 +113,20 @@ module Farce
     def storage_thread(thread)            = thread
     def prepare_mutable_numeric(_)        = nil
     def prepare_map_access(_klass, _kind) = nil
+    def prepare_shareable_class(_base)    = nil
     def finalize_engine                   = nil
     def with_scheduler_thread_group       = yield(ThreadGroup.new)
 
+    def initialize_range(target, first, last, exclude_end)
+      target.__send__(:initialize, first, last, exclude_end)
+    end
+
+    def publish_shareable(object)
+      Object.instance_method(:freeze).bind_call(object)
+      ::Ractor.make_shareable(object) if native_ractors?
+      object
+    end
+
     def delegate(from, to, *methods)
       methods.each do |method|
         if to.is_a?(Module)

data/lib/farce/lazy.rb

@@ -59,6 +59,9 @@ module Farce
   # # Will only compute the expensive attribute once, and return the same value to all Ractors.
   # 5.times { Ractor.new(object) { it.expensive_attribute } }
   # ```
+  #
+  # @see Farce::Memoize
+  # @see Farce::LazyRef
   class Lazy < Farce::Abstract::Lazy
     include Shareable::Tracked
 

data/lib/farce/lazy_ref.rb

@@ -22,6 +22,9 @@ module Farce
   #   #   initialized.value # => 0
   #   #   lazy_ref[:key] = :value
   #   #   initialized.value # => 1
+  #   #
+  #   # @see Farce::Memoize
+  #   # @see Farce::Lazy
   #   class LazyRef < Farce::Reference
   #     # @!macro modes
   #     # @overload initialize(factory, mode: :smart)

data/lib/farce/local/counter.rb

@@ -50,19 +50,13 @@ module Farce
 
       # Increment the counter atomically.
       # @param by [Numeric, String, #to_int] the amount, converted to an Integer
-      # @return [self]
-      def increment(by = 1)
-        internal_counter.increment(by)
-        self
-      end
+      # @return [Integer] the value produced by this atomic update
+      def increment(by = 1) = internal_counter.increment(by)
 
       # Decrement the counter atomically.
       # @param by [Numeric, String, #to_int] the amount, converted to an Integer
-      # @return [self]
-      def decrement(by = 1)
-        internal_counter.decrement(by)
-        self
-      end
+      # @return [Integer] the value produced by this atomic update
+      def decrement(by = 1) = internal_counter.decrement(by)
 
       alias subtract decrement
       alias remove   decrement

data/lib/farce/local/lease.rb

@@ -34,10 +34,10 @@ module Farce
       # (see Farce::Abstract::Lease#checkout)
       def checkout(timeout: nil, &block)
         deadline = timeout_deadline(timeout)
-        lease    = scoped_lease(timeout: remaining_timeout(deadline))
+        lease    = scoped_lease(timeout: Clock.remaining(deadline))
         raise TimeoutError, "lease checkout timed out" unless lease
 
-        timeout = remaining_timeout(deadline)
+        timeout = Clock.remaining(deadline)
         block ? lease.checkout(timeout:, &block) : lease.checkout(timeout:)
       end
 
@@ -65,13 +65,6 @@ module Farce
         end
         Clock.now + timeout
       end
-
-      def remaining_timeout(deadline)
-        return unless deadline
-
-        remaining = deadline - Clock.now
-        remaining.positive? ? remaining : 0
-      end
     end
   end
 end

data/lib/farce/local/lease_map.rb

@@ -35,10 +35,10 @@ module Farce
 
       def checkout_canonical(key, missing_key:, timeout: nil, &)
         deadline = timeout_deadline(timeout)
-        map      = scoped_lease_map(timeout: remaining_timeout(deadline))
+        map      = scoped_lease_map(timeout: Clock.remaining(deadline))
         raise TimeoutError, "lease checkout timed out" unless map
 
-        map.checkout(key, timeout: remaining_timeout(deadline), receiver: self, missing_key:, &)
+        map.checkout(key, timeout: Clock.remaining(deadline), receiver: self, missing_key:, &)
       end
 
       def try_checkout_canonical(key, missing_key:, &)
@@ -68,13 +68,6 @@ module Farce
         end
         Clock.now + timeout
       end
-
-      def remaining_timeout(deadline)
-        return unless deadline
-
-        remaining = deadline - Clock.now
-        remaining.positive? ? remaining : 0
-      end
     end
   end
 end

data/lib/farce/local/pool.rb

@@ -7,7 +7,8 @@ module Farce
     # A shareable handle with an independent thread pool in each scope.
     #
     # Each pool uses the scaling settings and fiber scheduler configured at
-    # construction. Tasks always keep their block and argument references. Only
+    # construction. Changing settings tunes the current scope's pool. New scopes
+    # use the constructor settings. Tasks always keep their block and argument references. Only
     # local and smart modes are accepted when `auto_local` is false. A scheduler
     # constructor must be convertible to a shareable proc for use in each Ractor.
     # {#close} drains only the current scope's pool. {#close_all} drains every pool
@@ -31,14 +32,45 @@ module Farce
                      grow_after: 0.005, shrink_after: 30, capacity: 1024, scope: :ractor,
                      backend: Internal::FROZEN_CONFIG.io_backend, &constructor)
         initialize_configuration(min_size:, max_size:, max_inflight:, grow_after:, shrink_after:, backend:)
-        @constructor = prepare_constructor(constructor || Internal::FROZEN_CONFIG.fiber_scheduler_constructor)
-        @pools       = Strict::Map.new
-        @closed_all  = Internal::Flag.new(false)
+        @capacity           = capacity && Integer(capacity)
+        @constructor        = prepare_constructor(constructor || Internal::FROZEN_CONFIG.fiber_scheduler_constructor)
+        @pools              = Strict::Map.new
+        @closed_all         = Internal::Flag.new(false)
         @initialization_key = Object.new.freeze
         super(scope:, min_size: @min_size, max_size: @max_size, max_inflight: @max_inflight,
               grow_after: @grow_after, shrink_after: @shrink_after, capacity:, backend:)
       end
 
+      # Settings changes affect only the current scope. New scopes use constructor defaults.
+      # @api private
+      def settings = (pool = current_pool) ? pool.settings : @settings.value
+
+      def capacity = (pool = current_pool) ? pool.capacity : @capacity
+
+      def min_size=(value)
+        scoped_value.min_size = value
+      end
+
+      def max_size=(value)
+        scoped_value.max_size = value
+      end
+
+      def max_inflight=(value)
+        scoped_value.max_inflight = value
+      end
+
+      def grow_after=(value)
+        scoped_value.grow_after = value
+      end
+
+      def shrink_after=(value)
+        scoped_value.shrink_after = value
+      end
+
+      def capacity=(value)
+        scoped_value.capacity = value
+      end
+
       # Stop accepting work in this scope and drain its queued tasks.
       # @return [self]
       def close
@@ -74,7 +106,8 @@ module Farce
       def closed? = @closed_all.value || super
 
       Internal.delegate(self, :scoped_value, :drained?, :admission_generation, :wait_for_admission,
-        :admission_changed, :task_taken, :retire_worker, :worker_stopped, :scale_if_needed)
+        :admission_changed, :task_taken, :retire_worker, :wake_retiring_workers,
+        :worker_retired, :worker_stopped, :scale_if_needed)
 
       private
 

data/lib/farce/local/publisher.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Local
+    # Local variant of {Farce::Publisher}.
+    class Publisher < Abstract::Publisher
+      include Shareable::Unfreezable
+
+      # The scope with independent contents.
+      # @return [Symbol] The configured scope name.
+      attr_reader :scope
+
+      # @overload initialize(*subscribers)
+      #   (see Farce::Abstract#initialize)
+      def initialize(*, scope: :ractor)
+        raise ArgumentError, "Invalid scope: #{scope.inspect}" unless Farce::SCOPES.include?(scope)
+        @scope = scope
+        super(*)
+      end
+
+      private
+
+      def map = Internal::Storage.store_if_absent(self, scope:) { Unshared::Map.new }
+
+      def default_mode = :local
+    end
+  end
+end

data/lib/farce/local/scheduler.rb

@@ -56,6 +56,7 @@ module Farce
       def initialize(capacity: 1024, backend: Internal::FROZEN_CONFIG.io_backend, scope: :ractor,
                      worker: nil, &constructor)
         @constructor        = prepare_constructor(constructor || Internal::FROZEN_CONFIG.fiber_scheduler_constructor)
+        @capacity           = capacity && Integer(capacity)
         @backend            = backend
         @worker             = worker
         @schedulers         = Strict::Map.new
@@ -65,15 +66,26 @@ module Farce
         super(scope:, capacity: capacity && Integer(capacity), backend:)
       end
 
+      # Pending-task capacity in this scope. New scopes retain the constructor value.
+      def capacity = (scheduler = current_scheduler) ? scheduler.capacity : @capacity
+
+      # Resize the queue in this scope without starting a worker.
+      def capacity=(value)
+        raise SchedulerClosedError, "cannot configure a closed scheduler" if @closed_all.value
+        scoped_value.capacity = value
+      end
+
       # Enqueue a task in the current scope, preserving its block and arguments.
       # `mode` is ignored when `auto_local` is true. Otherwise, only local and smart modes are accepted.
-      # @overload schedule(*args, mode: :smart, auto_local: true)
+      # @overload schedule(*args, mode: :smart, auto_local: true, timeout: nil)
       #   @param (see Farce::Abstract::Executor#schedule)
-      #   @return [self]
+      #   @return [self, nil] self when submitted, or nil when the scheduling timeout expires.
       def schedule(...) = enqueue_task(false, ...)
 
       # (see Abstract::Scheduler#try_schedule)
-      def try_schedule(...) = enqueue_task(true, ...)
+      def try_schedule(*, mode: :smart, auto_local: true, &)
+        enqueue_task(true, *, mode:, auto_local:, &)
+      end
 
       # Starts a worker for the current scope. Other scopes retain their creation behavior.
       # @param executor [Class, nil] Thread or a custom executor that stays in this Ractor.
@@ -147,12 +159,13 @@ module Farce
 
       private
 
-      def enqueue_task(non_block, *, mode: :smart, auto_local: true, &block)
+      def enqueue_task(non_block, *, mode: :smart, auto_local: true, timeout: nil, &block)
         raise SchedulerClosedError, "cannot schedule task on a closed scheduler" if @closed_all.value
         scheduler = scoped_value
         raise SchedulerClosedError, "cannot schedule task on a closed scheduler" if scheduler.closed?
         raise LocalJumpError, "Cannot schedule without a block" unless block
 
+        deadline = scheduling_deadline(timeout)
         validate_local_mode(mode, auto_local)
         register_scheduler(scheduler)
 
@@ -160,7 +173,7 @@ module Farce
           if non_block
             scheduler.try_schedule(*, mode:, auto_local:, &block)
           else
-            scheduler.schedule(*, mode:, auto_local:, &block)
+            scheduler.schedule(*, mode:, auto_local:, timeout: Clock.remaining(deadline), &block)
           end
 
         submitted && self

data/lib/farce/local/vector.rb

@@ -8,10 +8,11 @@ module Farce
     #
     # @!method initialize(source = nil, compare_by_identity: false, scope: :ractor)
     #   @!macro scopes
-    #   @param source [Array, nil] the initial values
+    #   @param source [Array, Integer, nil] Initial values or a size filled with nil.
     #   @param compare_by_identity [Boolean] whether values are compared by identity
     #   @param scope [Symbol] the scope of the vector
     #   @return [Vector]
+    #   @raise [ArgumentError] If the size is negative.
     class Vector < Abstract::Vector
       include Shareable::Tracked
       include Scoped::Tracked
@@ -24,7 +25,7 @@ module Farce
         self.class.new(values, compare_by_identity: compare_by_identity?, scope:)
       end
 
-      private def new_scoped_value(...) = Internal::UnsharedVector.new(...)
+      private def new_scoped_value(source = nil, **) = Internal::UnsharedVector.new(normalize_vector_source(source), **)
     end
   end
 end