farce 0.1.0-arm-linux-gnu → 0.2.0-arm-linux-gnu

data/lib/farce/timer_queue.rb

@@ -4,14 +4,14 @@
 
 module Farce
   # A shareable timer queue with transfer modes for unshareable values.
-  class TimerQueue < Abstract::TimerQueue
+  class TimerQueue < Farce::Abstract::TimerQueue
     include Internal::ManagedQueue
     include Shareable::Unfreezable
 
     # (see Farce::Abstract::TimerQueue#initialize)
     # @!macro modes
     # @param mode [Symbol] the transfer mode for unshareable values
-    def initialize(capacity: nil, mode: :copy, track_age: false)
+    def initialize(capacity: nil, mode: :smart, track_age: false)
       @manager = ModeManager.new(mode:)
       super(capacity:, track_age:)
     end
@@ -20,16 +20,20 @@ module Farce
     # @!macro modes
     # @param mode [Symbol] the transfer mode for unshareable values
     def push(value, non_block = false, mode: nil, timeout: nil, **time_options) # rubocop:disable Style/OptionalBooleanParameter
-      at = Clock.parse(time_options)
-      push_to_storage(at, non_block, @manager.wrap(value, mode:), timeout:)
+      at    = Clock.parse(time_options)
+      value = @manager.wrap(value, mode:)
+      entry = Entry.new(value, at, self)
+      push_to_storage(at, non_block, value, timeout:) && entry
     end
 
     # (see Farce::Abstract::TimerQueue#try_push)
     # @!macro modes
     # @param mode [Symbol] the transfer mode for unshareable values
     def try_push(value, mode: nil, **time_options)
-      at = Clock.parse(time_options)
-      return true if @queue.push(at, @manager.wrap(value, mode:))
+      at    = Clock.parse(time_options)
+      value = @manager.wrap(value, mode:)
+      entry = Entry.new(value, at, self)
+      return entry if @queue.push(at, value)
       block_given? ? yield : false
     end
 
@@ -62,5 +66,15 @@ module Farce
       return @manager.unwrap(value) unless empty
       yield if block_given?
     end
+
+    private
+
+    def delete_from_storage(priority, value, compare_by_identity:)
+      if compare_by_identity && @manager.managed_envelope?(value)
+        @queue.delete_identity(priority, value)
+      else
+        super
+      end
+    end
   end
 end

data/lib/farce/transaction/vector.rb

@@ -18,7 +18,12 @@ module Farce
 
       # (see Abstract::Vector#[])
       # @see Abstract::Vector#[]
-      def [](index) = access { unwrap_stored(@working[index]) }
+      def [](index, length = UNDEFINED)
+        access do
+          next unwrap_stored(@working[index]) if length.equal?(UNDEFINED) && !index.is_a?(Range)
+          slice(index, length)
+        end
+      end
 
       # (see Abstract::Vector#get)
       # @see Abstract::Vector#get
@@ -34,8 +39,12 @@ module Farce
 
       # (see Abstract::Vector#[]=)
       # @see Abstract::Vector#[]=
-      def []=(index, value)
-        store(index, value)
+      def []=(index, value, replacement = UNDEFINED)
+        if replacement.equal?(UNDEFINED) && !index.is_a?(Range)
+          store(index, value)
+        else
+          write { assign_vector_slice(index, value, replacement) }
+        end
       end
 
       # (see Abstract::Vector#store)
@@ -52,15 +61,24 @@ module Farce
 
       # (see Abstract::Vector#push)
       # @see Abstract::Vector#push
-      def push(value, mode: nil)
-        write { @working.push(wrap(value, mode:)) }
+      def push(value = UNDEFINED, *rest, mode: nil)
+        write do
+          if rest.empty? && !value.equal?(UNDEFINED)
+            @working.push(wrap(value, mode:))
+          else
+            push_values(value.equal?(UNDEFINED) ? rest : [value, *rest], mode:)
+          end
+        end
         self
       end
-      alias << push
+
+      def <<(value) = push(value)
 
       # (see Abstract::Vector#pop)
       # @see Abstract::Vector#pop
-      def pop = write { unwrap_stored(@working.pop) }
+      def pop(count = UNDEFINED)
+        write { count.equal?(UNDEFINED) ? unwrap_stored(@working.pop) : pop_values(count) }
+      end
 
       # (see Abstract::Vector#clear)
       # @see Abstract::Vector#clear
@@ -120,6 +138,17 @@ module Farce
       def internal_vector = @working
       def logical_value(value) = unwrap_stored(value)
 
+      def deletion_comparison(value)
+        return value unless @manager
+        @manager.wrap(value, mode: compare_by_identity? ? :local : :copy)
+      end
+
+      def deletion_match?(stored, expected)
+        return super unless @manager
+        unwrap_stored(stored)
+        @manager.same_value?(stored, expected, identity: compare_by_identity?)
+      end
+
       # Slice helpers return independent data rather than another participant.
       # Use an ordinary vector that remains usable after the attempt ends.
       def build_derived_vector(values)
@@ -130,10 +159,15 @@ module Farce
 
       def inspect_value(inspector, value) = super(inspector, value, @manager)
       def derived_storage(value)          = wrap(value)
+      def prepare_vector_value(value, mode: nil) = wrap(value, mode:)
 
-      Wrapper.inherit(self, :each_index, :reverse_each, :to_a, :deconstruct, :to_h, :join, :dig, :assoc,
+      Wrapper.inherit(self, :each_index, :reverse_each, :to_a, :to_ary, :deconstruct, :to_h, :join, :dig, :assoc,
         :rassoc, :at, :fetch, :fetch_values, :values_at, :slice, :rfind, :bsearch, :bsearch_index, :pack,
-        :length, :count, :compare_by_identity?, :shareable_values?)
+        :length, :count, :compare_by_identity?, :shareable_values?, :flatten, :transpose, :product,
+        :combination, :repeated_combination, :permutation, :repeated_permutation, :<=>,
+        writes: %i[delete delete_if map! collect! keep_if select! filter! reject! compact! uniq!
+                   reverse! rotate! shuffle! sort! sort_by! flatten! shift unshift prepend insert delete_at slice!
+                   replace fill append])
     end
   end
 end

data/lib/farce/transaction/wrapper.rb

@@ -15,6 +15,20 @@ module Farce
     module Wrapper
       include Internal::MarshalSupport::Reject
 
+      # Freezing an attempt view must not freeze its staged data or participant.
+      module Unfreezable
+        def append_features(mod)
+          super
+          if mod.is_a?(Class)
+            mod.class_eval { undef freeze if method_defined?(:freeze) }
+          else
+            mod.extend(Unfreezable)
+          end
+        end
+      end
+      private_constant :Unfreezable
+      extend Unfreezable
+
       # Wrappers inherit abstract container classes for their interfaces, but
       # must not initialize another ordinary container. This constructor ends
       # Unshareable's super chain after binding the existing transaction snapshot.

data/lib/farce/tree_map.rb

@@ -20,7 +20,7 @@ module Farce
     # @param entries [Hash, Array<Array(BasicObject, BasicObject)>, Abstract::Map, #each, nil]
     #   Optional initial entries for the map.
     # @param mode [Symbol] The default value transfer mode.
-    def initialize(entries = nil, mode: :copy, normalize_keys: nil, **keyword_entries)
+    def initialize(entries = nil, mode: :smart, normalize_keys: nil, **keyword_entries)
       unless keyword_entries.empty?
         raise ArgumentError, "entries given as both positional and keyword arguments" unless entries.nil?
         entries = keyword_entries

data/lib/farce/unsafe/lfu_map.rb

@@ -10,6 +10,7 @@ module Farce
     # does not coordinate competing callers, including callers loading the same key.
     class LFUMap < Abstract::LFUMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       # @!method store_if_absent(key)
       #   Read an existing value or construct and store a value for an absent key.
@@ -29,6 +30,7 @@ module Farce
       private
 
       def new_bounded_map(...) = Internal::LFUMap.new(...)
+      def freeze_backend       = @map
       def new_key_locks(**)    = nil
       def with_key_lock(_key)  = yield
     end

data/lib/farce/unsafe/lru_map.rb

@@ -10,6 +10,7 @@ module Farce
     # does not coordinate competing callers, including callers loading the same key.
     class LRUMap < Abstract::LRUMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       # @!method store_if_absent(key)
       #   Read an existing value or construct and store a value for an absent key.
@@ -29,6 +30,7 @@ module Farce
       private
 
       def new_bounded_map(...) = Internal::LRUMap.new(...)
+      def freeze_backend       = @map
       def new_key_locks(**)    = nil
       def with_key_lock(_key)  = yield
     end

data/lib/farce/unsafe/tree_map.rb

@@ -8,12 +8,14 @@ module Farce
     # A {Abstract::TreeMap tree map} that is not thread-safe and cannot be shared between Ractors.
     class TreeMap < Abstract::TreeMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       undef_method :transaction_wrapper
 
       private
 
       def new_tree_map(...)   = Internal::UnsafeTreeMap.new(...)
+      def freeze_backend      = @map
       def new_key_locks       = nil
       def with_key_lock(_key) = yield
     end

data/lib/farce/unshareable.rb

@@ -4,7 +4,7 @@
 
 module Farce
   # Mixin that makes sure instances cannot be shared between Ractors.
-  # @note Mixin in this module will remove the `freeze` method from the class.
+  # Instances may be frozen without becoming Ractor-shareable.
   #
   # @example
   #   class MyClass
@@ -12,26 +12,10 @@ module Farce
   #   end
   #
   #   object = MyClass.new
-  #   object.freeze # this would normally make it shareable
+  #   object.freeze # Preserves the Ractor restrictions.
   #
   #   Ractor.shareable?(object) # => false
   module Unshareable
-    # @api private
-    module UndefFreeze # :nodoc: all
-      # @api private
-      def append_features(mod)
-        super
-        if mod.is_a?(Class)
-          mod.class_eval { undef freeze if method_defined?(:freeze) }
-        else
-          mod.extend(UndefFreeze)
-        end
-      end
-    end
-
-    private_constant :UndefFreeze
-    extend UndefFreeze
-
     # Mixin for classes that cannot be shared across Ractors, but may be moved between them.
     module Movable
       include Unshareable
@@ -58,7 +42,12 @@ module Farce
     def pin_unshareable
       return unless Internal.native_ractors?
       case self
-      when Movable  then Internal::Unshareable.prevent_copyable(self) unless is_a?(Copyable)
+      when Movable
+        if is_a?(Copyable)
+          Internal::Unshareable.prevent_shareable(self)
+        else
+          Internal::Unshareable.prevent_copyable(self)
+        end
       when Copyable then Internal::Unshareable.prevent_movable(self)
       else Internal::Unshareable.pin_to_current_ractor(self)
       end

data/lib/farce/unshared/atom.rb

@@ -12,6 +12,7 @@ module Farce
     #   atom.update { |items| items + [:job] }
     class Atom < Abstract::Atom
       include Unshareable
+      include Internal::Freeze::Delegated
 
       # @param value [BasicObject, nil] the initial value
       # @param compare_by_identity [Boolean] whether comparisons use object identity
@@ -19,6 +20,8 @@ module Farce
         @atom = Internal::UnsharedAtom.new(value, compare_by_identity:)
         super()
       end
+
+      private def freeze_backend = @atom
     end
   end
 end

data/lib/farce/unshared/lfu_map.rb

@@ -7,10 +7,12 @@ module Farce
     # A thread-safe LFU map for mutable keys and values used within one Ractor.
     class LFUMap < Abstract::LFUMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       private
 
       def new_bounded_map(...) = Internal::LFUMap.new(...)
+      def freeze_backend = @map
 
       def new_key_locks(compare_keys_by_identity:)
         Internal::KeyLockMap.new(registry_class: Farce::Unshared::Map, compare_keys_by_identity:)

data/lib/farce/unshared/lru_map.rb

@@ -7,10 +7,12 @@ module Farce
     # A thread-safe LRU map for mutable keys and values used within one Ractor.
     class LRUMap < Abstract::LRUMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       private
 
       def new_bounded_map(...) = Internal::LRUMap.new(...)
+      def freeze_backend = @map
 
       def new_key_locks(compare_keys_by_identity:)
         Internal::KeyLockMap.new(registry_class: Farce::Unshared::Map, compare_keys_by_identity:)

data/lib/farce/unshared/map.rb

@@ -12,6 +12,7 @@ module Farce
     # `dup` and `clone` copy entries into independent storage while sharing stored values.
     class Map < Abstract::ConcurrentMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       # @!macro map_initialization
       #
@@ -44,6 +45,8 @@ module Farce
       end
 
       Internal.prepare_map_access(self, :unshared)
+
+      private def freeze_backend = @map
     end
   end
 end

data/lib/farce/unshared/set.rb

@@ -7,6 +7,7 @@ module Farce
     # A thread-safe set for mutable elements used within one Ractor.
     class Set < Farce::Abstract::Set
       include Unshareable
+      include Internal::Freeze::Delegated
 
       private def new_map(...) = Farce::Unshared::Map.new(...)
     end

data/lib/farce/unshared/sorted_set.rb

@@ -7,6 +7,7 @@ module Farce
     # A thread-safe set maintained in ascending order within one Ractor.
     class SortedSet < Farce::Abstract::SortedSet
       include Unshareable
+      include Internal::Freeze::Delegated
 
       class MutableTreeMap < Farce::Unshared::TreeMap # :nodoc:
         private

data/lib/farce/unshared/tree_map.rb

@@ -14,8 +14,12 @@ module Farce
     #   map[2].equal?(value) # => true
     class TreeMap < Abstract::TreeMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
-      private def new_tree_map(...) = Internal::TreeMap.new(...)
+      private
+
+      def new_tree_map(...) = Internal::TreeMap.new(...)
+      def freeze_backend    = @map
     end
   end
 end

data/lib/farce/unshared/vector.rb

@@ -7,6 +7,7 @@ module Farce
     # A thread-safe vector for mutable values used within one Ractor.
     class Vector < Abstract::Vector
       include Unshareable
+      include Internal::Freeze::Delegated
 
       # @param source [Array, nil] Initial values. Values are retained directly.
       # @param compare_by_identity [Boolean] Whether values are compared by identity.
@@ -14,6 +15,8 @@ module Farce
         @vector = Internal::UnsharedVector.new(source, compare_by_identity:)
         super()
       end
+
+      private def freeze_backend = @vector
     end
   end
 end

data/lib/farce/unshared/weak_atom.rb

@@ -24,8 +24,12 @@ module Farce
     #   atom.value.equal?(replacement)              # => true
     class WeakAtom < Abstract::WeakAtom
       include Unshareable
+      include Internal::Freeze::Delegated
 
-      private def internal_atom_class = Internal::UnsharedWeakAtom
+      private
+
+      def internal_atom_class = Internal::UnsharedWeakAtom
+      def freeze_backend      = @atom
     end
   end
 end

data/lib/farce/unshared/weak_key_map.rb

@@ -16,6 +16,7 @@ module Farce
     #   owner = nil
     class WeakKeyMap < Abstract::WeakKeyMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       def initialize(
         initial_mapping = nil,
@@ -39,6 +40,8 @@ module Farce
         Internal::KeyNormalizer.install_concurrent(self, normalizer) if restoring
         super()
       end
+
+      private def freeze_backend = @map
     end
   end
 end

data/lib/farce/unshared/weak_map.rb

@@ -16,6 +16,7 @@ module Farce
     #   value = nil
     class WeakMap < Abstract::WeakMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       def initialize(
         initial_mapping = nil,
@@ -39,6 +40,8 @@ module Farce
         Internal::KeyNormalizer.install_concurrent(self, normalizer) if restoring
         super()
       end
+
+      private def freeze_backend = @map
     end
   end
 end

data/lib/farce/unshared/weak_set.rb

@@ -7,6 +7,7 @@ module Farce
     # A thread-safe set that retains mutable elements weakly within one Ractor.
     class WeakSet < Farce::Abstract::WeakSet
       include Unshareable
+      include Internal::Freeze::Delegated
 
       private def new_map(...) = Farce::Unshared::WeakMap.new(...)
     end

data/lib/farce/unshared/weak_value_map.rb

@@ -15,6 +15,7 @@ module Farce
     #   value = nil
     class WeakValueMap < Abstract::WeakValueMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       def initialize(
         initial_mapping = nil,
@@ -38,6 +39,8 @@ module Farce
         Internal::KeyNormalizer.install_concurrent(self, normalizer) if restoring
         super()
       end
+
+      private def freeze_backend = @map
     end
   end
 end

data/lib/farce/vector.rb

@@ -10,9 +10,9 @@ module Farce
   #   vector = Farce::Vector.new([[]], mode: :make_shareable)
   #   vector.update(0) { |jobs| jobs + [:finished] } # => [:finished]
   #
-  # @!method append(value, mode: nil, timeout: nil)
-  #   Append one value using the same options as {#push}.
-  #   @param value [BasicObject] The value to append.
+  # @!method append(*values, mode: nil, timeout: nil)
+  #   Append values using the same options as {#push}.
+  #   @param values [Array<BasicObject>] The values to append.
   #   @param mode [Symbol, nil] The transfer mode, or nil to use the default.
   #   @param timeout [Numeric, nil] The maximum wait in seconds. Nil waits indefinitely.
   #   @return [self, false] Self on success, or false on timeout.
@@ -23,7 +23,7 @@ module Farce
     # @param source [Array, nil] Initial values. 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.
-    def initialize(source = nil, mode: :copy, compare_by_identity: false)
+    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"
@@ -64,13 +64,20 @@ module Farce
     def shareable_values? = true
 
     # (see Farce::Abstract::Vector#[])
-    def [](index) = @manager.unwrap(@vector[index])
+    def [](index, length = UNDEFINED)
+      return @manager.unwrap(@vector[index]) if length.equal?(UNDEFINED) && !index.is_a?(Range)
+      slice(index, length)
+    end
 
     # (see Farce::Abstract::Vector#[]=)
-    def []=(index, value)
-      check_frozen!
-      @vector[index] = @manager.wrap(value)
-      value
+    def []=(index, value, replacement = UNDEFINED)
+      if replacement.equal?(UNDEFINED) && !index.is_a?(Range)
+        check_frozen!
+        @vector[index] = @manager.wrap(value)
+        value
+      else
+        assign_vector_slice(index, value, replacement)
+      end
     end
 
     # (see Farce::Abstract::Vector#get)
@@ -85,13 +92,21 @@ module Farce
 
     # (see Farce::Abstract::Vector#push)
     # @param mode [Symbol, nil] The transfer mode, or nil to use the default.
-    def push(value, mode: nil, timeout: nil)
-      check_frozen!
-      @vector.push(@manager.wrap(value, mode:), timeout:) ? self : false
+    def push(value = UNDEFINED, *rest, mode: nil, timeout: nil)
+      if rest.empty? && !value.equal?(UNDEFINED)
+        check_frozen!
+        stored = mode.nil? ? @manager.wrap(value) : @manager.wrap(value, mode:)
+        completed = timeout.nil? ? @vector.push(stored) : @vector.push(stored, timeout:)
+        return completed ? self : false
+      end
+      push_values(value.equal?(UNDEFINED) ? rest : [value, *rest], mode:, timeout:)
     end
 
     # (see Farce::Abstract::Vector#pop)
-    def pop(timeout: nil) = @manager.unwrap(@vector.pop(timeout:))
+    def pop(count = UNDEFINED, timeout: nil)
+      return @manager.unwrap(timeout.nil? ? @vector.pop : @vector.pop(timeout:)) if count.equal?(UNDEFINED)
+      pop_values(count, timeout:)
+    end
 
     # (see Farce::Abstract::Vector#swap)
     # @!macro modes
@@ -183,7 +198,9 @@ module Farce
 
     protected
 
-    def logical_value(value) = @manager.unwrap(value)
+    def logical_value(value)              = @manager.unwrap(value)
+    def deletion_comparison(value)        = wrap_comparison(value)
+    def deletion_match?(stored, expected) = values_equal?(stored, expected)
 
     def build_derived_vector(values)
       self.class.allocate.initialize_derived_vector(values, @manager, @compare_by_identity)
@@ -206,11 +223,19 @@ module Farce
 
     private
 
-    def inspect_value(inspector, value) = super(inspector, value, @manager)
-    def derived_storage(value)          = @manager.wrap(value)
-    def freeze_backend                  = @vector
-    def wrap_comparison(value)          = @manager.wrap(value, mode: compare_by_identity? ? :local : :copy)
-    def values_equal?(left, right)      = @manager.same_value?(left, right, identity: compare_by_identity?)
+    def inspect_value(inspector, value)        = super(inspector, value, @manager)
+    def derived_storage(value)                 = @manager.wrap(value)
+    def prepare_vector_value(value, mode: nil) = @manager.wrap(value, mode:)
+
+    # Expanded descendants have no independent envelope to reuse. Copy them rather than
+    # moving them out of a retained parent Array or another sequence's storage.
+    def prepare_sequence_value(value)
+      @manager.wrap(value, mode: mode == :move ? :copy : nil)
+    end
+
+    def freeze_backend             = @vector
+    def wrap_comparison(value)     = @manager.wrap(value, mode: compare_by_identity? ? :local : :copy)
+    def values_equal?(left, right) = @manager.same_value?(left, right, identity: compare_by_identity?)
 
     def timeout_deadline(timeout)
       return if timeout.nil?

data/lib/farce/version.rb

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

data/lib/farce.rb

@@ -54,7 +54,10 @@ module Farce
 
   # The valid transfer modes for values that are not Ractor-shareable.
   # @return [::Set<Symbol>]
-  MODES = ::Set[:copy, :move, :local, :make_shareable, :mutable, :raise, :shareable_copy, :dedup, :proxy].freeze
+  MODES = ::Set[
+    :copy, :marshal, :move, :local, :make_shareable, :mutable, :raise, :shareable_copy, :dedup, :proxy,
+    :smart, :smart_raise, :smart_move, :smart_copy,
+  ].freeze
 
   UNDEFINED = Internal::Undefined.new("UNDEFINED")
 
@@ -171,7 +174,7 @@ module Farce
     DEDUPER.dedup(object, **)
   end
 
-  # @overload enfarce(object, freeze: nil, mode: :copy)
+  # @overload enfarce(object, freeze: nil, mode: :smart)
   #   Converts vanilla Ruby objects into their {Farce} equivalents.
   #
   #   @!macro modes
@@ -396,7 +399,7 @@ module Farce
   #   # Hi from the current ractor!
   #   # Hi again from the main ractor!
   #
-  # @overload on_main(*args, mode: :copy)
+  # @overload on_main(*args, mode: :smart)
   #   @param args [Array] The arguments to be passed to the block.
   #   @param mode [Symbol] The argument transfer mode when called from another ractor.
   #   @yield [*args] The block to be executed on the main ractor.
@@ -418,7 +421,7 @@ module Farce
     if Ractor.main?
       yield(*args)
     else
-      mode = :copy if UNDEFINED.equal?(mode)
+      mode = :smart if UNDEFINED.equal?(mode)
       Internal::MainScheduler.execute(*args, mode:, auto_local: false, &)
     end
 
@@ -438,7 +441,7 @@ module Farce
   #   Farce.in_parallel("hello") { |message| puts message.upcase }
   #   Farce.in_parallel.schedule { puts "another task" }
   #
-  # @overload in_parallel(*args, mode: :copy)
+  # @overload in_parallel(*args, mode: :smart)
   #   @param args [Array<Object>] Arguments passed to the block.
   #   @param mode [Symbol] Argument transfer mode. Ignored on JRuby and TruffleRuby.
   #   @yield [*args] The task to schedule.
@@ -455,12 +458,12 @@ module Farce
       return Internal::ParallelScheduler
     end
 
-    mode = :copy if UNDEFINED.equal?(mode)
+    mode = :smart if UNDEFINED.equal?(mode)
     Internal::ParallelScheduler.schedule(*args, mode:, &)
     nil
   end
 
-  # @overload schedule(*args, mode: :copy, auto_local: true, **kwargs)
+  # @overload schedule(*args, mode: :smart, auto_local: true, **kwargs)
   #   Schedules work to be executed out of band.
   #
   #   If the `mode` is set to `:local`, it will use the current thread's fiber scheduler to schedule the task.
@@ -486,7 +489,7 @@ module Farce
   #   @param kwargs [Hash] Additional keyword arguments passed to the scheduler.
   #   @yield [*args] The task to schedule.
   #   @return [nil]
-  def self.schedule(*, mode: :copy, auto_local: true, **, &)
+  def self.schedule(*, mode: :smart, auto_local: true, **, &)
     raise LocalJumpError, "no block given" unless block_given?
 
     if auto_local || mode == :local