farce 0.0.1.alpha2-x86_64-linux-gnu

data/lib/farce/transaction/wrapper.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  class Transaction
+    # Binds container wrappers to the transaction attempt that created them.
+    #
+    # Wrappers call {#access} or {#write} around operations on staged data.
+    # These checks reject calls from another Fiber or after the attempt ends.
+    # They also invalidate the attempt when an operation raises, so rescuing
+    # the error cannot publish writes staged before that failed operation.
+    #
+    # @api private
+    module Wrapper
+      include Internal::MarshalSupport::Reject
+
+      # 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.
+      module Initialization
+        # Bind the wrapper to its participant and active attempt.
+        # Enroll backend when the wrapper owns storage. Composite wrappers use
+        # other wrappers for their snapshots and leave backend nil.
+        # @param transaction [Transaction] the current attempt
+        # @param object [Object] the original participant
+        # @param backend [Object, nil] the participant's storage to enroll, if any
+        # @param manager [ModeManager, nil] the participant's value transfer manager
+        # @param nil_value [BasicObject, nil] the backend's sentinel for stored nil
+        def initialize(transaction, object, backend = nil, manager: nil, nil_value: nil)
+          @transaction = transaction
+          @object      = object
+          @backend     = backend
+          @manager     = manager
+          @nil_value   = nil_value
+          @entry       = enlist(backend) if backend
+          @working     = @entry&.working
+        end
+      end
+      private_constant :Initialization
+
+      include Initialization
+      include Unshareable
+
+      # Allow transaction[wrapper] to reuse a wrapper from this same attempt.
+      # A different attempt cannot adopt its snapshot or staged writes.
+      # @param transaction [Transaction] the attempt requesting the wrapper
+      # @return [self]
+      # @raise [TypeError] if the wrapper belongs to a different attempt
+      def transaction_wrapper(transaction)
+        access do
+          raise TypeError, "wrapper belongs to another transaction" unless @transaction.equal?(transaction)
+          self
+        end
+      end
+
+      # Select the abstract container helpers that can operate on staged data.
+      # Each wrapper supplies its supported helpers. Other inherited operations
+      # may wait on live storage, copy the participant, or bypass its snapshot.
+      #
+      # @param klass [Class] the wrapper class to configure
+      # @param helpers [Array<Symbol>] inherited reads to retain and guard
+      # @param writes [Array<Symbol>] inherited writes that must also check the
+      #   original participant's frozen state
+      # @return [Class] the configured wrapper class
+      def self.inherit(klass, *helpers, writes: [])
+        helpers += writes
+        helpers |= %i[inspect pretty_print inspect_with] if klass.method_defined?(:inspect_with)
+        owners     = klass.ancestors.take_while { |ancestor| ancestor != klass.superclass }
+        own        = klass.public_instance_methods.select { owners.include?(klass.instance_method(it).owner) }
+        enumerable = klass <= Enumerable ? Enumerable.public_instance_methods : []
+
+        # Set and Vector override map/select to construct self.class. Use
+        # Enumerable's Array results so these calls do not construct wrappers
+        # without a transaction and participant.
+        enumerable.each do |name|
+          next if own.include?(name) || helpers.include?(name)
+          klass.define_method(name, Enumerable.instance_method(name))
+        end
+
+        guards   = Module.new
+        rejected = klass.superclass.public_instance_methods - Object.public_instance_methods -
+          enumerable - helpers - own
+        rejected.each { |name| klass.class_eval { undef_method(name) } }
+
+        # Metadata reads and empty-input calls can return without touching
+        # storage. Guard the helper itself so these also reject closed attempts.
+        helpers.each do |name|
+          next if own.include?(name)
+          operation = writes.include?(name) ? :write : :access
+          guards.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{name}(...)
+              #{operation} { super }
+            end
+          RUBY
+        end
+        klass.prepend(guards)
+      end
+
+      private
+
+      def enlist(backend) = @transaction.enlist(backend)
+
+      # Initialize a composite wrapper after binding it to the participant.
+      # Copy the named settings, then replace each storage field with its
+      # wrapper from this attempt. Set uses this to retain membership settings
+      # while its map handles snapshots and commit validation.
+      # @param settings [Array<Symbol>] participant instance variables, without @
+      # @param components [Hash{Symbol => Object}] storage fields, without @,
+      #   and the original objects to wrap
+      def compose(*settings, **components)
+        settings.each do |name|
+          variable = :"@#{name}"
+          instance_variable_set(variable, @object.instance_variable_get(variable))
+        end
+        components.each { |name, object| instance_variable_set(:"@#{name}", @transaction[object]) }
+      end
+
+      # A rescued NoMethodError must still discard earlier staged writes.
+      # Local wrappers retain the participant's scope getter, with the same
+      # lifetime check as reads of staged values.
+      def method_missing(name, *arguments, **options, &block)
+        if name == :scope && arguments.empty? && options.empty? && !block && @object.respond_to?(:scope)
+          return access { @object.scope }
+        end
+        @transaction.fail!(retryable: false)
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        (name == :scope && @object.respond_to?(:scope)) || super
+      end
+
+      def require_block!(present)
+        return if present
+        @transaction.fail!(retryable: false)
+        raise LocalJumpError, "no block given"
+      end
+
+      def access
+        @transaction.check_open!
+        yield
+      rescue Internal::TransactionConflict
+        @transaction.fail! if @transaction.state == :active
+        raise
+      rescue Exception # rubocop:disable Lint/RescueException -- cancellation must poison the attempt too
+        @transaction.fail!(retryable: false) if @transaction.state == :active
+        raise
+      end
+
+      def initialize_copy(*)
+        access do
+          @transaction.fail!(retryable: false)
+          raise TypeError, "transaction wrappers cannot be copied"
+        end
+      end
+
+      def check_frozen! = Internal::Freeze.check(@object)
+
+      def write
+        access do
+          raise FrozenError, "cannot modify frozen transaction participant" if @object.frozen?
+          @transaction.guard(@object)
+          @entry&.write!
+          yield
+        end
+      end
+
+      def wrap(value, mode: nil)
+        return @nil_value if value.nil? && @nil_value
+        return value unless @manager
+        selected = mode || @manager.mode
+
+        # These modes can change ownership or freeze supplied objects before
+        # commit. Discarding staged storage cannot undo those effects.
+        if %i[move make_shareable dedup proxy].include?(selected)
+          raise TypeError, "#{selected} transfers do not support transactions"
+        end
+
+        @manager.wrap(value, mode:)
+      end
+
+      def unwrap_stored(value)
+        return if @nil_value.equal?(value)
+        return value unless @manager
+        raise TypeError, "move envelopes do not support transactions" if Envelope::Move === value
+        @manager.unwrap(value)
+      end
+
+      def matches?(current, expected, identity:)
+        comparison = @manager.wrap(expected, mode: identity ? :local : :copy)
+        comparison = @nil_value if expected.nil? && @nil_value
+        @manager.same_value?(current, comparison, identity:)
+      end
+
+      def compared(result)
+        @transaction.fail! unless result
+        result
+      end
+    end
+  end
+end

data/lib/farce/transaction.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # A transaction groups multiple changes to Farce objects into a single atomic attempt.
+  #
+  # These changes either all succeed together when the transaction is committed
+  # or are all discarded if the transaction fails.
+  #
+  # Transaction attempts are isolated and can be retried safely.
+  #
+  # You must therefore make sure that any side-effects not going through transaction wrappers
+  # are either completely avoided, or at least made idempotent.
+  #
+  # ```ruby
+  # account1 = Farce::Atom.new(10)
+  # account2 = Farce::Atom.new(20)
+  #
+  # # Wire 10 from account1 to account2
+  # Farce.transaction do |tx|
+  #   raise "insufficient funds" unless tx[account1].value >= 10
+  #   tx[account1].update { it - 10 }
+  #   tx[account2].update { it + 10 }
+  # end
+  # ```
+  #
+  # Transactions can mix different types and variants, and are therefore ideal for coordinating complex, coordinated
+  # changes affecting data within multiple scopes.
+  #
+  # ## Supported objects
+  #
+  # Out of the box, transactions support instances of the following classes:
+  # * Atoms, except weak atoms
+  # * ConcurrentMap subclasses, except weak maps
+  # * Molecules
+  # * Mutable wrappers with frozen snapshots
+  # * Sets, including sorted sets
+  # * TreeMap subclasses
+  # * Vectors
+  # * Concurrent::TVar from the concurrent-ruby gem
+  # * Ractor::TVar from the ractor-sharing gem
+  # * Ractor::TMVar from the ractor-tmvar gem
+  class Transaction
+    include Internal::MarshalSupport::Reject
+    include Internal::Autoloads
+    include Unshareable
+
+    # Raised when a wrapper is used outside its transaction attempt.
+    ClosedError    = Class.new(StandardError)
+    # Raised when another Fiber uses a transaction.
+    OwnershipError = Class.new(StandardError)
+    Aborted        = Class.new(StandardError)
+    private_constant :Aborted, :MapOperations, :SetOperations
+
+    # @note This method must be called from the main Ractor, and the block must be convertible to a shareable proc.
+    #
+    # Registers a wrapper for a custom class, allowing them to be used within transactions.
+    #
+    # @example
+    #   Account = Struct.new(:balance) do
+    #     def withdraw(amount) = balance.value -= amount
+    #   end
+    #
+    #   Farce::Transaction.define(Account) do |account, tx|
+    #     account.class.new(tx[account.balance])
+    #   end
+    #
+    #   account = Account.new(Farce::Atom.new(10))
+    #   Farce.transaction { |tx| tx[account].withdraw(3) }
+    #   account.balance.value # => 7
+    #
+    # @param klass [Class] the class to wrap
+    # @yieldparam object [Object] the participant
+    # @yieldparam transaction [Transaction] the current attempt
+    # @yieldreturn [Object] the transaction wrapper
+    def self.define(klass, &)
+      raise LocalJumpError, "no block given" unless block_given?
+      definition = Internal.prepare_method_definition(&)
+      REGISTER.define(klass) { define_method(:call, definition) }
+    end
+
+    # Default factory for participants without a registered wrapper definition.
+    # @api private
+    class Factory
+      include Shareable::Immutable
+
+      # Ask a participant's hook to build a wrapper for the supplied attempt.
+      # @param object [#transaction_wrapper] the participant to wrap
+      # @param transaction [Transaction] the current attempt
+      # @return [Object] the wrapper returned by the participant's hook
+      def call(object, transaction)
+        raise TypeError, "#{object.class} does not support transactions" unless object.respond_to?(:transaction_wrapper)
+        object.transaction_wrapper(transaction)
+      end
+    end
+
+    REGISTER = ClassMirror.new(Factory) { |mapped, _source| mapped.new }
+    private_constant :Factory, :REGISTER
+
+    # @overload run(*objects, retries: nil, backoff_after: 10, max_backoff: 1.0)
+    #   Creates and runs a new transaction attempt.
+    #
+    #   Automatically retries failed attempts indefinitely unless a retry limit is specified.
+    #   Starts backing off after the specified number of attempts, up to the maximum delay.
+    #
+    #   @param objects [Array] list of objects to enroll in the transaction
+    #   @param retries [Integer, nil] maximum additional attempts, or nil for unlimited retries
+    #   @param backoff_after [Integer] number of attempts before starting to back off
+    #   @param max_backoff [Numeric] maximum backoff delay in seconds
+    #   @return [Boolean] whether the transaction committed successfully
+    #   @see Farce.transaction
+    def self.run(*, retries: nil, backoff_after: 10, max_backoff: 1.0, &) # rubocop:disable Naming/PredicateMethod
+      raise LocalJumpError, "no block given" unless block_given?
+
+      unless retries.nil? || (Integer === retries && retries >= 0)
+        raise ArgumentError, "retries must be nil or a non-negative Integer"
+      end
+
+      unless Integer === backoff_after && backoff_after >= 0
+        raise ArgumentError, "backoff_after must be a non-negative Integer"
+      end
+
+      attempt = 0
+
+      while retries.nil? || attempt <= retries
+        if attempt > backoff_after
+          delay     = (attempt - backoff_after) * 0.01
+          delay     = max_backoff if delay > max_backoff
+          scheduler = Fiber.scheduler if Fiber.respond_to?(:scheduler) && !Fiber.current.blocking?
+          scheduler ? scheduler.kernel_sleep(delay) : sleep(delay)
+        end
+
+        transaction = new
+        return true if transaction.run(*, &)
+        return false unless transaction.retryable?
+
+        attempt += 1
+      end
+
+      false
+    end
+
+    # Create an unused attempt bound to the current Fiber.
+    # Call {#run} once to enroll participants and stage writes. Use {.run} when
+    # failed comparisons or conflicts should create and run fresh attempts.
+    def initialize
+      @owner     = Fiber.current
+      @state     = :new
+      @failed    = @aborted = false
+      @retryable = true
+      @wrappers  = {}.compare_by_identity
+      @entries   = {}.compare_by_identity
+      @guards    = {}.compare_by_identity
+      super
+    end
+
+    # Report the attempt's lifecycle state.
+    # @return [Symbol] :new before run, :active during the block, :committing
+    #   during publication, then :committed or :failed
+    attr_reader :state
+
+    # Whether abort! was called during this attempt.
+    # @return [Boolean]
+    def aborted? = @aborted
+
+    # Whether .run may retry this attempt after a failed commit or comparison.
+    # Explicit aborts, wrapper exceptions, and fail!(retryable: false) disable retries.
+    # @return [Boolean]
+    def retryable? = @retryable && !@aborted
+
+    # Execute this attempt once. Use {.run} for automatic retries.
+    #
+    # The block stages work through {#[]}. After it returns, commit validates
+    # the attempt's reads and publishes its staged writes together.
+    # Cancellation during commit is deferred until publication finishes. Once
+    # committed, an interruption does not undo the changes.
+    #
+    # @param objects [Array] the objects to enroll in this transaction attempt
+    # @yield [transaction, *objects] the current transaction and the enrolled objects
+    # @yieldparam transaction [Transaction] this active attempt
+    # @yieldparam objects [Array] the enrolled objects
+    # @return [Boolean] whether the changes committed
+    # @raise [ClosedError] if this attempt has already run
+    # @raise [OwnershipError] if called from a different Fiber
+    def run(*objects)
+      started = false
+      raise LocalJumpError, "no block given" unless block_given?
+      check_owner!
+      raise ClosedError, "transaction has already run" unless @state == :new
+
+      @state  = :active
+      started = true
+
+      objects.map! { self[it] }
+      yield self, *objects
+
+      check_open!
+
+      Thread.handle_interrupt(Internal::INTERRUPT_MASK) do
+        @state = :committing
+        entries = @entries.values
+        unless @failed
+          entries = entries.filter_map { Internal::TransactionMapSnapshot === it ? it.prepare_commit : it }
+        end
+        committed = !@failed && Internal.commit_transaction(entries, @guards.values, self)
+        @state    = committed ? :committed : :failed
+        Internal.notify_transaction(entries) if committed && entries.none? { it.respond_to?(:commit_group) } &&
+          Internal.respond_to?(:notify_transaction)
+        committed
+      end
+    rescue Aborted, Internal::TransactionConflict
+      false
+    ensure
+      if started
+        @state = :failed if %i[active committing].include?(@state)
+        Thread.handle_interrupt(Internal::INTERRUPT_MASK) do
+          @entries.each_value { it.release if it.respond_to?(:release) }
+        end
+      end
+    end
+
+    # Includes an object in this transaction and returns a transaction-aware version of it.
+    # Read from and write to the returned object, so the transaction can keep track of inputs and changes.
+    #
+    # @param object [Object] the participant or a wrapper from this attempt
+    # @return [Object] a wrapper valid only during this attempt
+    # @raise [TypeError] if the participant is unsupported or belongs to another attempt
+    def [](object)
+      check_open!
+      @wrappers.fetch(object) do
+        klass = Kernel.instance_method(:class).bind_call(object)
+        @wrappers[object] = REGISTER[klass].call(object, self)
+      end
+    rescue Internal::TransactionConflict
+      fail! if @state == :active && @owner.equal?(Fiber.current)
+      raise
+    rescue Exception # rubocop:disable Lint/RescueException -- cancellation must poison the attempt too
+      if @state == :active && @owner.equal?(Fiber.current)
+        @failed = true
+        @retryable = false
+      end
+      raise
+    end
+
+    # Stop the transaction block and discard all staged writes without retrying.
+    # The surrounding run call returns false. No writes to participants are published.
+    #
+    # @example
+    #   balance = Farce::Atom.new(100)
+    #
+    #   Farce.transaction do |tx|
+    #     tx.abort! if tx[balance] < 100
+    #     tx[balance].value -= 100
+    #   end
+    # @return [void]
+    def abort!
+      check_open!
+      @failed = @aborted = true
+      raise Aborted, "transaction aborted"
+    end
+
+    # Mark a failed condition, even if the caller ignores its return value.
+    #
+    # The block may continue, but commit will discard its staged writes.
+    # Custom wrappers can use this for their own conditional operations.
+    #
+    # Wrapper operations call this automatically when they raise. If you rescue
+    # an error before a wrapper is called, such as an argument computation error,
+    # call `fail!(retryable: false)` to prevent earlier writes from committing.
+    #
+    # @param retryable [Boolean] whether .run may repeat the block for this failure
+    # @return [false]
+    def fail!(retryable: true) # rubocop:disable Naming/PredicateMethod
+      check_open!
+      @failed = true
+      @retryable &&= retryable
+      false
+    end
+
+    # Check lifetime and Fiber ownership before a wrapper accesses staged data.
+    # @raise [ClosedError] if the attempt is not active
+    # @raise [OwnershipError] if called from a different Fiber
+    # @api private
+    def check_open!
+      check_owner!
+      raise ClosedError, "transaction attempt is closed" unless @state == :active
+    end
+
+    # Enroll storage once and reuse its staged data across wrappers.
+    #
+    # Backends that expose transaction_source share enrollment with that source,
+    # so wrappers of the same storage cannot stage conflicting independent copies.
+    #
+    # An optional block builds an entry for integrations whose sources do not
+    # expose transaction_snapshot. It runs once per source in each attempt.
+    # Without a block, enrollment uses the source's snapshot hook.
+    #
+    # Entries may implement release to free resources held during the attempt.
+    # It is called after commit or on any exit that discards staged writes.
+    #
+    # @param backend [Object] storage to enroll, optionally exposing transaction_source
+    # @param per_key [Boolean] track map dependencies when using the source's snapshot hook
+    # @yieldparam source [Object] the canonical source whose entry is being created
+    # @yieldreturn [#working] the entry containing staged storage and commit hooks
+    # @return [#working] the enrolled entry containing this attempt's staged storage
+    # @api private
+    def enlist(backend, per_key: false)
+      check_open!
+      source = backend.respond_to?(:transaction_source) ? backend.transaction_source : backend
+      @entries.fetch(source) do
+        unless block_given? || source.respond_to?(:transaction_snapshot)
+          raise TypeError, "#{source.class} does not support transactions"
+        end
+        Thread.handle_interrupt(Internal::INTERRUPT_MASK) do
+          @entries[source] = if block_given?
+                               yield source
+                             elsif per_key
+                               Internal::TransactionMapSnapshot.new(source)
+                             else
+                               source.transaction_snapshot
+                             end
+        end
+      end
+    end
+
+    # Include a Local participant's shared freeze flag in commit validation.
+    # Its scoped backend alone cannot reveal that another scope froze the handle.
+    #
+    # @param object [Object] the participant being written
+    # @api private
+    def guard(object)
+      return unless Local::Scoped === object
+      @guards[object] = object.instance_variable_get(:@farce_freeze_state)
+    end
+
+    private
+
+    def check_owner!
+      raise OwnershipError, "transaction belongs to another Fiber" unless @owner.equal?(Fiber.current)
+    end
+  end
+end

data/lib/farce/tree_map.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # A Ractor-shareable map that keeps entries sorted by key.
+  # Transfer modes apply only to values. Keys are stored directly, except that mutable strings become immutable.
+  # Values stored through this map's mode manager are automatically unwrapped.
+  #
+  # @example Keeping copied values in key order
+  #   map = Farce::TreeMap.new(mode: :copy)
+  #   map[2] = ["draft"]
+  #   map[1] = ["published"]
+  #
+  #   map.values # => [["published"], ["draft"]]
+  class TreeMap < Farce::Abstract::TreeMap
+    include Shareable::Delegated
+
+    # @!macro modes
+    # @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)
+      unless keyword_entries.empty?
+        raise ArgumentError, "entries given as both positional and keyword arguments" unless entries.nil?
+        entries = keyword_entries
+      end
+      @manager = marshal_mode_manager(mode)
+      super(entries, normalize_keys:)
+    end
+
+    # The default transfer mode for values.
+    # @return [Symbol]
+    def mode = @manager.mode
+
+    # Values are stored in Ractor-shareable representations.
+    # @return [true]
+    def shareable_values? = true
+
+    protected
+
+    def unwrap_value(value) = @manager.unwrap(value)
+
+    def wrap_value(value)
+      check_frozen!
+      @manager.wrap(value)
+    end
+
+    private
+
+    def each_for_inspect(&)             = internal_map.each(&)
+    def inspect_value(inspector, value) = super(inspector, value, @manager)
+    def new_tree_map(...)               = Internal::StrictTreeMap.new(...)
+    def freeze_backend                  = internal_map
+  end
+end

data/lib/farce/unsafe/lfu_map.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Unsafe
+    # @!macro unsafe
+    # An LFU map for caches whose caller provides exclusive access to composed operations.
+    # Individual storage operations retain the engine backend's integrity guard. Cache loading
+    # does not coordinate competing callers, including callers loading the same key.
+    class LFUMap < Abstract::LFUMap
+      include Unshareable
+
+      # @!method store_if_absent(key)
+      #   Read an existing value or construct and store a value for an absent key.
+      #   Competing callers can run the loader concurrently, including for equal keys.
+      #   The caller must provide exclusive access when a single initialization is required.
+      #   @param key [BasicObject] The key to retrieve or initialize.
+      #   @yieldreturn [BasicObject] The value to store.
+      #   @return [BasicObject] The existing or newly stored value.
+      #   @raise [LocalJumpError] If no block is given.
+
+      # (see Abstract::Map#[])
+      def []=(key, value)
+        internal_map[prepare_key(key)] = value
+        value
+      end
+
+      private
+
+      def new_bounded_map(...) = Internal::LFUMap.new(...)
+      def new_key_locks(**)    = nil
+      def with_key_lock(_key)  = yield
+    end
+  end
+end

data/lib/farce/unsafe/lru_map.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Unsafe
+    # @!macro unsafe
+    # An LRU map for caches whose caller provides exclusive access to composed operations.
+    # Individual storage operations retain the engine backend's integrity guard. Cache loading
+    # does not coordinate competing callers, including callers loading the same key.
+    class LRUMap < Abstract::LRUMap
+      include Unshareable
+
+      # @!method store_if_absent(key)
+      #   Read an existing value or construct and store a value for an absent key.
+      #   Competing callers can run the loader concurrently, including for equal keys.
+      #   The caller must provide exclusive access when a single initialization is required.
+      #   @param key [BasicObject] The key to retrieve or initialize.
+      #   @yieldreturn [BasicObject] The value to store.
+      #   @return [BasicObject] The existing or newly stored value.
+      #   @raise [LocalJumpError] If no block is given.
+
+      # (see Abstract::Map#[])
+      def []=(key, value)
+        internal_map[prepare_key(key)] = value
+        value
+      end
+
+      private
+
+      def new_bounded_map(...) = Internal::LRUMap.new(...)
+      def new_key_locks(**)    = nil
+      def with_key_lock(_key)  = yield
+    end
+  end
+end

data/lib/farce/unsafe/tree_map.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Unsafe
+    # @!macro unsafe
+    # A {Abstract::TreeMap tree map} that is not thread-safe and cannot be shared between Ractors.
+    class TreeMap < Abstract::TreeMap
+      include Unshareable
+
+      undef_method :transaction_wrapper
+
+      private
+
+      def new_tree_map(...)   = Internal::UnsafeTreeMap.new(...)
+      def new_key_locks       = nil
+      def with_key_lock(_key) = yield
+    end
+  end
+end