farce 0.0.1.alpha2-x86_64-linux-gnu

data/lib/farce/abstract/map.rb

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Abstract
+    # @abstract Superclass for all maps defined by Farce.
+    # @note
+    #  The supported methods are generally compatible with their Hash counterparts,
+    #  with the notable exception of {ConcurrentMap#update}.
+    #
+    # A Hash-like collection with slightly reduced functionality to allow for better concurrency models.
+    #
+    # Constructors accept a Hash, another map, or an object whose #each yields key/value pairs.
+    # Arrays of pairs and enumerators are supported. Initial entries are inserted in source order.
+    # Local maps retain the initial entries for reuse in each scope.
+    #
+    # `dup` and `clone` create independent storage and coordination while sharing keys and stored values.
+    # Value modes and key normalization are preserved without transferring values again.
+    # Copies of shareable maps remain shareable unless explicitly cloned with `freeze: false`.
+    # Local copies retain the current scope's contents. Other scopes use the original constructor configuration.
+    # Lease maps reject copying because resources cannot safely be given independent ownership controls.
+    #
+    # Iteration order is implementation-dependent. In particular, insertion order is not guaranteed.
+    #
+    # Implementations can compare keys and values either by equality or by identity. Operations accepting a
+    # `timeout` wait at most that many seconds to acquire the access needed for the operation. A timeout must be a
+    # finite, non-negative number, `nil` waits indefinitely.
+    #
+    # @!method [](key)
+    #   Look up a key without waiting for atomic-update access.
+    #   @param key [BasicObject] The key to look up.
+    #   @return [BasicObject, nil] The associated value, or nil if the key is absent.
+    #   @abstract
+    #
+    # @!method []=(key, value)
+    #   Associate a value with a key without a timeout.
+    #   @param key [BasicObject] The key to store.
+    #   @param value [BasicObject] The value to store.
+    #   @return [BasicObject] `value`.
+    #   @abstract
+    #
+    # @!method store_if_absent(key)
+    #   Read an existing value or construct and store a value for an absent key.
+    #   Existing nil and false values count as present when the implementation permits them.
+    #   The block runs without holding a map-wide lock. Implementations document their
+    #   coordination guarantees, ownership requirements, and optional timeout support.
+    #   A later removal or eviction can cause another call to construct a new value.
+    #   @param key [BasicObject] The key to look up or store.
+    #   @yield Called without arguments when the key is absent.
+    #   @yieldreturn [BasicObject] The value to store and return.
+    #   @return [BasicObject] The existing or newly constructed value.
+    #   @raise [LocalJumpError] If no block is given.
+    #   @abstract
+    #
+    # @!method clear
+    #   Remove all entries from the map.
+    #   @return [self]
+    #   @abstract
+    #
+    # @!method compare_keys_by_identity?
+    #   @return [Boolean] Whether keys are compared by identity instead of `hash` and `eql?`.
+    #   @abstract
+    #
+    # @!method compare_values_by_identity?
+    #   @return [Boolean] Whether values are compared by identity instead of equality.
+    #   @abstract
+    #
+    # @!method delete(key)
+    #   Remove a key and its associated value.
+    #   @param key [BasicObject] The key to remove.
+    #   @return [BasicObject, nil] The removed value, or nil if the key was absent.
+    #   @abstract
+    #
+    # @!method each
+    #   Iterate over the map's key-value pairs.
+    #   Entry consistency and access requirements depend on the implementation. Iteration order is not guaranteed
+    #   to match insertion order.
+    #   @overload each
+    #     @yield [pair] Called once for each entry.
+    #     @yieldparam pair [Array<BasicObject>] A two-element `[key, value]` pair.
+    #     @return [self]
+    #   @overload each
+    #     @return [Enumerator] An enumerator over two-element `[key, value]` pairs.
+    #   @abstract
+    #
+    # @!method each_key
+    #   Iterate over the keys currently stored in the map.
+    #   Keys are not guaranteed to be yielded in insertion order.
+    #   @overload each_key
+    #     @yield [key] Called once for each stored key.
+    #     @yieldparam key [BasicObject] A stored key.
+    #     @return [self]
+    #   @overload each_key
+    #     @return [Enumerator] An enumerator over the stored keys.
+    #   @abstract
+    #
+    # @!method each_pair
+    #   Iterate over key-value pairs in the same manner as {#each}.
+    #   @see #each
+    #   @abstract
+    #
+    # @!method each_value
+    #   Iterate over the values currently stored in the map.
+    #   Values are not guaranteed to be yielded in insertion order.
+    #   @overload each_value
+    #     @yield [value] Called once for each stored value.
+    #     @yieldparam value [BasicObject] A stored value.
+    #     @return [self]
+    #   @overload each_value
+    #     @return [Enumerator] An enumerator over the stored values.
+    #   @abstract
+    #
+    # @!method fetch(key, *defaults)
+    #   Fetch the value associated with a key, using the same missing-key behavior as Hash#fetch.
+    #   If both a default and a block are provided, the block takes precedence and a warning is emitted.
+    #   @overload fetch(key)
+    #     @param key [BasicObject] The key to look up.
+    #     @return [BasicObject] The associated value.
+    #     @raise [KeyError] If the key is absent.
+    #   @overload fetch(key, default)
+    #     @param key [BasicObject] The key to look up.
+    #     @param default [BasicObject] The value to return if the key is absent.
+    #     @return [BasicObject] The associated value or `default`.
+    #   @overload fetch(key)
+    #     @param key [BasicObject] The key to look up.
+    #     @yield [key] Called if the key is absent.
+    #     @yieldparam key [BasicObject] The missing key.
+    #     @yieldreturn [BasicObject] The value to return.
+    #     @return [BasicObject] The associated value or the block result.
+    #   @abstract
+    #
+    # @!method getkey(key)
+    #   Return the stored key that matches a lookup key.
+    #   @param key [BasicObject] The key to match.
+    #   @return [BasicObject, nil] The matching stored key, or nil if no key matches.
+    #   @abstract
+    #
+    # @!method key?(key)
+    #   Test whether a key is present, including when its associated value is nil.
+    #   @param key [BasicObject] The key to look up.
+    #   @return [Boolean] Whether the key is present.
+    #   @abstract
+    #
+    # @!method keys
+    #   Return the keys currently stored in the map.
+    #   The returned keys are not guaranteed to be in insertion order.
+    #   @return [Array<BasicObject>] A new array containing the stored keys.
+    #   @abstract
+    #
+    # @!method size
+    #   Return the number of entries currently in the map.
+    #   @return [Integer] The number of entries.
+    #   @abstract
+    class Map
+      include Internal::MarshalSupport::Map
+      include Enumerable
+      include Internal::Inspect
+
+      # Store a value using the map's assignment operation.
+      # Concurrent maps override this method to support timeouts.
+      # @param key [BasicObject] the key to store
+      # @param value [BasicObject] the value to store
+      # @return [BasicObject] `value`
+      def store(key, value) = self[key] = value
+
+      # Return a two-element array containing a key and its associated value, if the key is present,
+      # or nil if the key is absent.
+      # @param key [BasicObject] The key to look up.
+      # @return [Array(BasicObject, BasicObject), nil] A two-element `[key, value]` array, or nil if the key is absent.
+      def assoc(key)
+        value = fetch(key) { return nil }
+        [key, value]
+      end
+
+      # (see #compare_keys_by_identity?)
+      def compare_by_identity? = compare_keys_by_identity?
+
+      # Implements Ruby's [dig interface](https://docs.ruby-lang.org/en/master/language/dig_methods_rdoc.html).
+      # @param key [BasicObject] The key to look up.
+      # @param rest [Array<BasicObject>] Additional keys to look up in nested maps.
+      # @return [BasicObject, nil] The value found at the nested location, or nil if any key is absent or nil.
+      def dig(key, *rest)
+        value = self[key]
+        return value if rest.empty? || value.nil?
+        value.dig(*rest)
+      end
+
+      # Returns whether the map contains no entries.
+      # @return [Boolean] Whether the map is empty.
+      def empty? = size.zero?
+
+      # Return the number of entries currently in the map.
+      # @return [Integer]
+      def length = size
+
+      # Return whether an observed value matches using this map's value comparison setting.
+      # Values are unwrapped before comparison. Concurrent changes may make the result stale.
+      # @param value [BasicObject] the value to find
+      # @return [Boolean]
+      def value?(value)
+        identity = compare_values_by_identity?
+        each_value.any? { |stored| identity ? stored.equal?(value) : stored == value }
+      end
+      alias has_value? value?
+
+      # Return a matching key using this map's value comparison setting, or nil.
+      # The first observed match is returned. No insertion order is guaranteed.
+      # @param value [BasicObject] the value to find
+      # @return [BasicObject, nil]
+      def key(value)
+        pair = rassoc(value)
+        pair&.first
+      end
+
+      # Return an observed key/value pair using this map's value comparison setting, or nil.
+      # Values are unwrapped before comparison. Concurrent changes may make the result stale.
+      # @param value [BasicObject] the value to find
+      # @return [Array, nil]
+      def rassoc(value)
+        identity = compare_values_by_identity?
+        each_pair do |key, stored|
+          return [key, stored] if identity ? stored.equal?(value) : stored == value
+        end
+        nil
+      end
+
+      # Alias for {#key?}
+      def has_key?(...) = key?(...) # rubocop:disable Naming/PredicatePrefix
+      alias member?  has_key?
+      alias include? has_key?
+
+      # Fetches the values associated with multiple keys, using the same missing-key behavior as Hash#fetch.
+      # @yield [key] Called for each missing key.
+      # @yieldparam key [BasicObject] The missing key.
+      # @yieldreturn [BasicObject] The value to return for the missing key.
+      # @param keys [Array<BasicObject>] The keys to look up.
+      # @return [Array<BasicObject>] An array of the associated values.
+      def fetch_values(*keys, &) = keys.map { fetch(it, &) }
+
+      # @note
+      #   Some maps may still accept non-shareable keys or values, but convert them into shareable representations.
+      #   This method will still return `true` for such maps.
+      #
+      # @return [Boolean] Whether the map requires keys to be Ractor-shareable
+      def shareable_keys? = false
+
+      # @return [Boolean] Whether the map requires values to be Ractor-shareable
+      def shareable_values? = false
+
+      # Creates a new Array containing the map's key-value pairs as two-element arrays.
+      # @return [Array<Array(BasicObject, BasicObject)>>] A new Array of `[key, value]` arrays.
+      def to_a = each_pair.to_a
+
+      # Creates a new Hash containing the map's entries.
+      # Preserves identity comparison for keys, including when a block transforms entries.
+      # @yieldparam key [BasicObject] an existing key
+      # @yieldparam value [BasicObject] its value
+      # @yieldreturn [Array(BasicObject, BasicObject)] the key and value for the new Hash
+      # @return [Hash] A new Hash with the original entries, or the pairs returned by the block.
+      def to_h(&) = entries_to_hash(each_pair, &)
+
+      # Support implicit Hash conversion using this map's {#to_h} implementation.
+      # @return [Hash] A new Hash containing the map's entries.
+      def to_hash = to_h
+
+      # Support hash patterns using the same entries and key comparison as {#to_h}.
+      # Like Hash, this returns all entries regardless of the requested keys.
+      # @param keys [Array, nil] the optional key hint supplied by Ruby's pattern matcher
+      # @return [Hash] A new Hash containing the map's entries.
+      def deconstruct_keys(keys) = to_h # rubocop:disable Lint/UnusedMethodArgument
+
+      # Fetches the values associated with multiple keys, returning nil for any missing keys.
+      # @param keys [Array<BasicObject>] The keys to look up.
+      # @return [Array<BasicObject>] An array of the associated values, with nil for any missing keys.
+      def values_at(*keys) = keys.map { self[it] }
+
+      # Some maps reference their keys weakly, automatically dropping entries when a key gets garbage-collected.
+      # @return [Boolean] Whether the map uses weak references for keys.
+      def weak_keys? = false
+
+      # Some maps reference their values weakly, automatically dropping entries when a value gets garbage-collected.
+      # @return [Boolean] Whether the map uses weak references for values.
+      def weak_values? = false
+
+      # @return [String] String representation of the map, suitable for debugging.
+      def to_s = inspect
+
+      # @api private
+      def inspect_with(inspector)
+        super do
+          yield if block_given?
+          inspector.breakable
+          inspector.group("{", "}") do
+            inspector.breakable ""
+            inspector.seplist(self, nil, :each_for_inspect) do |key, value|
+              inspector.group { inspect_pair(inspector, key, value) }
+            end
+          end
+        end
+      end
+
+      protected
+
+      # Convert a public value to its stored representation.
+      # @api private
+      def wrap_value(value) = value
+
+      # Convert a stored representation to its public value.
+      # @api private
+      def unwrap_value(value) = value
+
+      private
+
+      def entries_to_hash(entries, &)
+        return entries.to_h(&) unless compare_keys_by_identity?
+        hash = {}.compare_by_identity
+        entries.each do |key, value|
+          if block_given?
+            pair = Array.try_convert(yield(key, value))
+            raise TypeError, "block must return an Array or respond to #to_ary" unless pair
+            raise ArgumentError, "block must return a two-element pair" unless pair.size == 2
+            key, value = pair
+          end
+          hash[key] = value
+        end
+        hash
+      end
+
+      def convert_entries(entries)
+        return entries if Map === entries
+        if entries.respond_to?(:to_hash)
+          entries = Hash.try_convert(entries)
+          raise TypeError, "entries must be a Hash or respond to #to_hash" unless entries
+        end
+        return entries if entries.nil? || entries.respond_to?(:each)
+        raise TypeError, "entries must yield key/value pairs with #each"
+      end
+
+      def each_for_inspect(&)                 = each(&)
+      def inspect_pair(inspector, key, value) = inspector.hash_pair(key, value) { inspect_value(inspector, value) }
+      def inspect_value(inspector, ...)       = inspector.object(...)
+    end
+  end
+end

data/lib/farce/abstract/molecule.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Abstract
+    # @abstract A record whose fields are independently atomic references.
+    #
+    # Define a record class with {.define}, then read or assign its named fields.
+    # Use each field's `<name>_atom` for updates, comparisons, and waits.
+    # Operations on several fields are not a transaction or a consistent snapshot.
+    class Molecule
+      include Internal::MarshalSupport::Initialize
+      include Internal::Freeze::Tracked
+      include Internal::Inspect
+      include Enumerable
+
+      EMPTY_ARRAY = [].freeze
+      private_constant :EMPTY_ARRAY
+
+      ACCESSORS = Module.new do
+        def get        = public_send(:"#{__callee__}_atom").value
+        def set(value) = public_send(:"#{__callee__.to_s.delete_suffix("=")}_atom").value = value
+        def atom       = @molecule_atoms.fetch(__callee__, nil)
+
+        def atom=(value)
+          @molecule_atoms[__callee__.to_s.delete_suffix("=").to_sym] = value
+        end
+      end
+
+      private_constant :ACCESSORS
+
+      # Create a record class with readers, writers, and `<name>_atom` accessors.
+      # Missing initial values default to nil. Generated classes may be subclassed.
+      # @param fields [Array<Symbol, String>] unique field names
+      # @param compare_by_identity [Boolean, nil] the default comparison policy, or nil to inherit
+      # @return [Class<Molecule>] the record class
+      # @raise [ArgumentError] if names conflict with the record interface
+      def self.define(*fields, compare_by_identity: nil)
+        fields = fields.map(&:to_sym)
+        names  = fields.flat_map { [it, :"#{it}=", :"#{it}_atom", :"#{it}_atom="] }
+
+        conflicts = names.any? do |name|
+          next true if name == :freeze
+          next false unless method_defined?(name) || private_method_defined?(name)
+          instance_method(name).owner != Enumerable
+        end
+
+        if names.uniq.length != names.length || conflicts
+          raise ArgumentError, "field names must be unique and must not override the molecule interface"
+        end
+
+        Class.new(self) do
+          singleton_class.class_eval { undef define }
+          unless nil.equal?(compare_by_identity)
+            class_eval "def self.compare_by_identity? = #{(!!compare_by_identity).inspect}", __FILE__, __LINE__ - 1
+          end
+
+          atoms = []
+          members = fields.map do |field|
+            define_member(field)
+            atoms << :"#{field}_atom"
+            field
+          end
+
+          @atoms   = Ractor.make_shareable(atoms.freeze)
+          @members = Ractor.make_shareable(members.freeze)
+
+          set_temporary_name("#{superclass.name}#{@members.inspect}")
+        end
+      end
+
+      # @api private
+      def self.[](...) = define(...)
+
+      # @return [Boolean] the default comparison policy for new records
+      def self.compare_by_identity? = false
+
+      # @!visibility private
+      def self.define_member(field)
+        raise ArgumentError, "#{field.inspect} is not a valid field name" if field == :compare_by_identity
+        if field =~ /\A[a-z_]\w*\z/i
+          attr_accessor :"#{field}_atom"
+          private :"#{field}_atom="
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{field} = self.#{field}_atom.value
+
+            def #{field}=(value)
+              self.#{field}_atom.value = value
+            end
+          RUBY
+        else
+          define_method(:"#{field}_atom",  ACCESSORS.instance_method(:atom))
+          define_method(:"#{field}_atom=", ACCESSORS.instance_method(:atom=))
+          define_method(field,             ACCESSORS.instance_method(:get))
+          define_method(:"#{field}=",      ACCESSORS.instance_method(:set))
+          private :"#{field}_atom="
+        end
+      end
+      private_class_method :define_member
+
+      # @return [Array<Symbol>] the atom accessor names in declaration order
+      def self.atoms
+        return @atoms if defined?(@atoms) && @atoms
+        return superclass.atoms if superclass.respond_to?(:atoms)
+        EMPTY_ARRAY
+      end
+
+      # @return [Array<Symbol>] the field names in declaration order
+      def self.members
+        return @members if defined?(@members) && @members
+        return superclass.members if superclass.respond_to?(:members)
+        EMPTY_ARRAY
+      end
+
+      # Initialize fields by position or name. A field may only be supplied once.
+      # Existing {Atom} instances are retained directly, preserving their policy.
+      # @param input [Array<BasicObject>] values in declaration order
+      # @param attributes [Hash{Symbol => BasicObject}] values by field name
+      # @param compare_by_identity [Boolean, nil] the comparison policy, or nil for the class default
+      # @raise [ArgumentError] for unknown, repeated, or excess values
+      def initialize(*input, compare_by_identity: nil, **attributes)
+        raise ArgumentError, "too many positional values" if input.length > members.length
+        @compare_by_identity = compare_by_identity.nil? ? self.class.compare_by_identity? : !!compare_by_identity # rubocop:disable Style/DoubleNegation
+        @molecule_atoms = {}
+        input.each_with_index { initialize_atom(members[_2], _1) }
+        attributes.each { initialize_atom(_1, _2) }
+        members.each { initialize_atom(it, nil) unless public_send(:"#{it}_atom") }
+        @molecule_atoms.freeze
+        super()
+      end
+
+      # @api private
+      def marshal_dump
+        options = { compare_by_identity: compare_by_identity? }
+        options[:mode] = mode if respond_to?(:mode)
+        options[:scope] = scope if respond_to?(:scope)
+        fields = members.map { |member| [member, public_send(:"#{member}_atom")] }
+        [1, fields, options, frozen?]
+      end
+
+      # @api private
+      def marshal_load(data)
+        fields, options, frozen = Internal::MarshalSupport.payload(data, 3)
+        initialize(**fields.to_h, **options)
+        Internal::MarshalSupport.freeze(self, frozen)
+      end
+
+      # @api private
+      def transaction_wrapper(transaction) = Transaction::Molecule.new(transaction, self)
+
+      # Whether newly created atoms compare by identity instead of equality.
+      # Explicitly supplied atoms retain their own comparison policy.
+      # @return [Boolean]
+      def compare_by_identity? = @compare_by_identity
+
+      # (see .atoms)
+      def atoms = self.class.atoms
+
+      # (see .members)
+      def members = self.class.members
+
+      # Yield field names and current values in declaration order.
+      # @yieldparam member [Symbol] the field name
+      # @yieldparam value [BasicObject] its current value
+      # @return [Array<Symbol>, Enumerator]
+      def each
+        return enum_for(:each) unless block_given?
+        members.each { yield it, public_send(it) }
+      end
+      alias each_pair each
+
+      # Yield atom accessor names and atomic references in declaration order.
+      # @yieldparam name [Symbol] the atom accessor name
+      # @yieldparam atom [Atom] the field's atomic reference
+      # @return [Array<Symbol>, Enumerator]
+      def each_atom
+        return enum_for(:each_atom) unless block_given?
+        atoms.each { yield it, public_send(it) }
+      end
+
+      # Yield field names in declaration order.
+      # @return [Array<Symbol>, Enumerator]
+      def each_member
+        return enum_for(:each_member) unless block_given?
+        members.each { yield it }
+      end
+      alias each_key each_member
+
+      # Yield current field values in declaration order.
+      # @return [Array<Symbol>, Enumerator]
+      def each_value
+        return enum_for(:each_value) unless block_given?
+        members.each { yield public_send(it) }
+      end
+
+      # Prevent field replacement and atom updates without freezing stored values.
+      # Coordinate with writers before freezing. This is not a snapshot operation.
+      # @return [self]
+      def freeze
+        return self if frozen?
+        each_atom { |_, atom| atom.freeze }
+        super
+      end
+
+      # @api private
+      def inspect_with(inspector)
+        super do
+          yield if block_given?
+          each_member do |member|
+            inspector.breakable
+            inspector.text("#{member}=")
+            atom = public_send(:"#{member}_atom")
+            atom.__send__(:inspect_value, inspector, nil)
+          end
+        end
+      end
+
+      private
+
+      # @abstract Build the atomic reference for one field.
+      # @param key [Symbol] the field name
+      # @param value [BasicObject] its initial value
+      # @return [Atom]
+      def create_atom(_key, _value) = raise NoMethodError, "create_atom must be implemented in the subclass"
+
+      def initialize_atom(key, value)
+        getter = :"#{key}_atom"
+        setter = :"#{key}_atom="
+
+        raise ArgumentError, "#{key.inspect} is not a valid member" unless respond_to?(getter)
+        current = public_send(:"#{key}_atom")
+
+        if respond_to?(setter, true)
+          raise ArgumentError, "#{key} has already been initialized" if current
+          value = create_atom(key, value) unless Atom === value
+          __send__(:"#{key}_atom=", value)
+        else
+          raise TypeError, "expected #{getter.inspect} to return an Atom" unless current.is_a?(Atom)
+          current.value = value
+        end
+      end
+    end
+  end
+end

data/lib/farce/abstract/port.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Abstract
+    # @abstract Common interface and ownership tracking for Farce ports.
+    # @note
+    #   This is a module so both implementations can inherit directly from the runtime's port backend.
+    #
+    # @!method send(message)
+    #   Sends a message through the port.
+    #   @param message [BasicObject] the message to send
+    #   @return [self]
+    #   @raise [Farce::Ractor::ClosedError] if the port is closed
+    #
+    # @!method receive(timeout: nil)
+    #   Waits for a message or the timeout. Only the owning Ractor can receive.
+    #   @param timeout [Numeric, nil] the maximum seconds to wait, or nil to wait indefinitely
+    #   @return [BasicObject, nil] the received message, or nil on timeout
+    #   @raise [Farce::Ractor::ClosedError] if the port is closed
+    #
+    # @!method close
+    #   Closes the port. Only the owning Ractor can close it.
+    #   @return [self]
+    #
+    # @!method closed?
+    #   @return [Boolean] whether the port is closed
+    module Port
+      include Internal::MarshalSupport::Reject
+      include Internal::Noncopyable
+      include Shareable::Native
+      include Shareable::Unfreezable
+
+      # @api private
+      def initialize(...)
+        # Native Ractor ports cannot hold Ruby instance variables.
+        Internal::Storage.ractor[self] = true
+        super
+      end
+
+      # Checks whether the current Ractor created this port.
+      # @return [Boolean] whether the current Ractor owns the port
+      def owned? = !!Internal::Storage.ractor[self]
+
+      # Forwards all arguments to {#send}.
+      # @return [self]
+      def <<(...) = send(...)
+
+      # Forwards all arguments to {#send}.
+      # @return [self]
+      def push(...) = send(...)
+
+      # Forwards all arguments to {#receive}.
+      # @return [BasicObject, nil] the received message, or nil on timeout
+      def pop(...) = receive(...)
+
+      # @api private
+      def pretty_print(pp)
+        string = inspect
+        return pp.text(string) unless match = string.match(/\A#<([\w:]+)((?: \w+:#?\w+)+)>\z/)
+
+        pp.group(1, "#<#{match[1]}", ">") do
+          match[2].split.each do |pair|
+            pp.breakable " "
+            key, value = pair.split(":", 2)
+            pp.text "#{key}:"
+            pp.text value
+          end
+        end
+      end
+    end
+  end
+end