farce 0.0.1.alpha2-java

data/lib/farce/integrations/active_support/map.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group ActiveSupport Integration
+require "farce/integrations/active_support"
+
+module Farce
+  module Abstract
+    class Map
+      # @!macro active_support
+      # Convert entries using ActiveSupport's Hash JSON conversion.
+      # @return [Hash] The entries converted using Hash#as_json.
+      def as_json(...) = to_h.as_json(...)
+
+      # @!macro active_support
+      # Encode public entries as a query string, optionally under a namespace.
+      # @return [String]
+      def to_query(...) = to_h.to_query(...)
+      alias to_param to_query
+
+      # @!macro active_support
+      # Validate observed keys without normalizing the allowed keys.
+      # Concurrent changes may invalidate the result immediately.
+      # @return [self]
+      # @raise [ArgumentError] if an observed key is not allowed
+      def assert_valid_keys(*valid_keys)
+        valid_keys.flatten!
+        each_key do |key|
+          unless valid_keys.include?(key)
+            raise ArgumentError, "Unknown key: #{key.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(", ")}"
+          end
+        end
+        self
+      end
+    end
+
+    module DuplicableMap
+      # @!macro active_support
+      # Return a new map of the same class with interchangeable Symbol and String keys.
+      # Other key types and nested hashes are not normalized. Existing normalization is replaced.
+      # The copy preserves its value mode, value comparison, capacity, and Local scope where supported.
+      # Keys use equality. Entries from the current scope seed a Local copy.
+      # Values in move mode are copied to preserve the source.
+      # @return [Map] An independent map with indifferent key access.
+      def with_indifferent_access
+        normalizer = Ractor.shareable_proc { |key| Symbol === key ? key.name : key }
+        build_indifferent_access(**indifferent_access_options, normalize_keys: normalizer)
+      end
+
+      # @!macro active_support
+      # Deeply copy entries into a map of the same kind with the same settings.
+      # String and Symbol keys retain their identity, as with ActiveSupport's Hash#deep_dup.
+      # Copied keys and values must satisfy the map's normal storage rules.
+      # @return [Map]
+      def deep_dup
+        copier = ModeManager.new(mode: :copy) if respond_to?(:mode) && mode == :move
+        with_map_copy(empty: true) do |copy, map|
+          internal_map.each do |key, value|
+            key = key.deep_dup unless String === key || Symbol === key
+            value = unwrap_value(value).deep_dup
+            value = copier.unwrap(copier.wrap(value)) if copier
+            map[key] = copy.wrap_value(value)
+          end
+        end
+      end
+
+      # @!macro active_support
+      # Return a same-kind map with string keys, subject to its key normalizer.
+      # @return [Map]
+      def stringify_keys = transform_keys { |key| Symbol === key ? key.name : key.to_s }
+
+      # @!macro active_support
+      # Return a same-kind map with symbol keys where conversion succeeds.
+      # @return [Map]
+      def symbolize_keys
+        transform_keys do |key|
+          key.to_sym
+        rescue StandardError
+          key
+        end
+      end
+      alias to_options symbolize_keys
+
+      # @!macro active_support
+      # Return a same-kind map without blank values, including false.
+      # @return [Map]
+      def compact_blank = reject { |_, value| value.blank? }
+
+      # @!macro active_support
+      # Return a same-kind map with defaults applied before the receiver's entries.
+      # Existing entries win. Bounded copies rebuild eviction history and enforce their capacity.
+      # Move-mode defaults are copied so the input remains usable.
+      # @param other [Map, Hash, #to_hash] default entries
+      # @return [Map]
+      def reverse_merge(other)
+        unless Map === other
+          other = Hash.try_convert(other) || raise(TypeError, "input must be a Map, Hash, or respond to #to_hash")
+        end
+        copier = ModeManager.new(mode: :copy) if respond_to?(:mode) && mode == :move
+        with_map_copy(empty: true) do |copy, map|
+          other.each_pair do |key, value|
+            key = normalize_copied_key(key)
+            value = copier.unwrap(copier.wrap(value)) if copier
+            map[key] = copy.wrap_value(value)
+          end
+          internal_map.each { |key, value| map[key] = value }
+        end
+      end
+      alias with_defaults reverse_merge
+
+      private
+
+      def indifferent_access_options = respond_to?(:mode) ? { mode: mode } : {}
+
+      def build_indifferent_access(**options)
+        entries = self
+        if options[:mode] == :move
+          copier  = ModeManager.new(mode: :copy)
+          entries = each_pair.map { |key, value| [key, copier.unwrap(copier.wrap(value))] }
+        end
+        self.class.new(entries, **options)
+      end
+    end
+
+    class ConcurrentMap
+      # @!macro active_support
+      # Remove blank values using per-key coordination. Always return self.
+      # The operation is not atomic across keys.
+      # @return [self]
+      def compact_blank! = delete_if { |_, value| value.blank? }
+
+      # @!macro active_support
+      # Store each default only if its key is absent, preserving existing nil and false values.
+      # Each decision is atomic for its key. Earlier changes survive exceptions.
+      # Inserted values use the map's transfer mode, including move semantics.
+      # @param other [Map, Hash, #to_hash] default entries
+      # @return [self]
+      def reverse_merge!(other)
+        unless Map === other
+          other = Hash.try_convert(other) || raise(TypeError, "input must be a Map, Hash, or respond to #to_hash")
+        end
+        other.each_pair { |key, value| store_if_absent(key) { value } }
+        self
+      end
+      alias with_defaults! reverse_merge!
+
+      private
+
+      def indifferent_access_options
+        super.merge(compare_keys_by_identity: false, compare_values_by_identity: compare_values_by_identity?)
+      end
+    end
+
+    class BoundedMap
+      private
+
+      def indifferent_access_options
+        super.merge(max_size:, compare_keys_by_identity: false, compare_values_by_identity: compare_values_by_identity?)
+      end
+    end
+  end
+
+  module Local
+    module Scoped
+      module Map
+        private def indifferent_access_options = super.merge(scope:)
+      end
+    end
+  end
+
+  Internal::Converter.define(ActiveSupport::HashWithIndifferentAccess, :Map) do
+    def prepare(...) = super.with_indifferent_access
+  end
+end

data/lib/farce/integrations/active_support/set.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group ActiveSupport Integration
+require "farce/integrations/active_support"
+
+module Farce
+  module Abstract
+    class Set
+      # @!macro active_support
+      # Deeply copy elements into a set of the same kind with the same settings.
+      # Copied elements pass through the set's normal storage rules.
+      # Weak results do not keep copied heap elements alive by themselves.
+      # @return [Farce::Abstract::Set]
+      def deep_dup = map_canonical(&:deep_dup)
+
+      # @!macro active_support
+      # Return a same-kind set without blank elements.
+      # @return [Farce::Abstract::Set]
+      def compact_blank = reject(&:blank?)
+
+      # @!macro active_support
+      # Remove blank elements and return self.
+      # @return [self]
+      def compact_blank! = delete_if(&:blank?)
+
+      # @!macro active_support
+      # Return a same-kind set with elements added. Array arguments are flattened by one level.
+      # @param elements [Array<BasicObject>] Elements or Arrays of elements to add.
+      # @return [Farce::Abstract::Set] A new set of the same class with the same settings.
+      def including(*elements) = union(elements.flatten(1))
+
+      # @!macro active_support
+      # Return a same-kind set without the supplied elements. Array arguments are flattened by one level.
+      # @param elements [Array<BasicObject>] Elements or Arrays of elements to remove.
+      # @return [Farce::Abstract::Set] A new set of the same class with the same settings.
+      def excluding(*elements) = difference(elements.flatten(1))
+      alias without excluding
+
+      # @!macro active_support
+      # Convert the elements through ActiveSupport's Array JSON conversion.
+      # @overload as_json(options = nil)
+      #   @param options [Hash, nil] Options passed to each element's JSON conversion.
+      #   @return [Array] The JSON-compatible values.
+      def as_json(...) = to_a.as_json(...)
+
+      # @!macro active_support
+      # Return the elements' ActiveSupport parameter representation.
+      # @return [String]
+      def to_param = to_a.to_param
+
+      # @!macro active_support
+      # Encode the elements as repeated query parameters under a key.
+      # @param key [String, Symbol] The query parameter name.
+      # @return [String] The encoded query string.
+      def to_query(key) = to_a.to_query(key)
+    end
+  end
+end

data/lib/farce/integrations/active_support/value_serialization.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group ActiveSupport Integration
+require "farce/integrations/active_support"
+
+module Farce
+  module Internal::ValueSerialization
+    # @!macro active_support
+    # Convert the current value using ActiveSupport's JSON conversion.
+    # @overload as_json(options = nil)
+    #   @param options [Hash, nil] Options forwarded to the current value's as_json.
+    #   @return [Object, nil] The JSON-compatible value.
+    def as_json(...) = value.as_json(...)
+  end
+end

data/lib/farce/integrations/active_support/vector.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group ActiveSupport Integration
+require "farce/integrations/active_support"
+
+module Farce
+  module Abstract
+    class Vector
+      # @!macro active_support
+      # Return entries starting at position from one snapshot.
+      # @param position [Integer] The starting index. Negative indexes count from the end.
+      # @return [Vector] The tail, or an empty Vector for an out-of-range position.
+      def from(position)
+        snapshot = internal_vector.snapshot
+        build_derived_vector(snapshot.from(position))
+      end
+
+      # @!macro active_support
+      # Return entries through position from one snapshot.
+      # @param position [Integer] The final index. Negative indexes count from the end.
+      # @return [Vector] The prefix, or an empty Vector for an out-of-range negative position.
+      def to(position) = build_derived_vector(internal_vector.snapshot.to(position))
+
+      # @!macro active_support
+      # Append entries to a new Vector, flattening argument Arrays by one level.
+      # New entries follow the receiver's storage rules and transfer mode.
+      # @param elements [Array<BasicObject>] The entries or Arrays of entries to append.
+      # @return [Vector] The combined entries.
+      def including(*elements) = self + elements.flatten(1)
+
+      # @!macro active_support
+      # Exclude entries using Array's hash-based difference semantics.
+      # @param elements [Array<BasicObject>] Entries to exclude, with Arrays flattened by one level.
+      # @return [Vector] The remaining entries.
+      def excluding(*elements) = self - elements.flatten(1)
+      alias without excluding
+
+      # @!macro active_support
+      # @return [BasicObject, nil] The second entry, or nil if absent.
+      def second = self[1]
+
+      # @!macro active_support
+      # @return [BasicObject, nil] The third entry, or nil if absent.
+      def third = self[2]
+
+      # @!macro active_support
+      # @return [BasicObject, nil] The fourth entry, or nil if absent.
+      def fourth = self[3]
+
+      # @!macro active_support
+      # @return [BasicObject, nil] The fifth entry, or nil if absent.
+      def fifth = self[4]
+
+      # @!macro active_support
+      # @return [BasicObject, nil] The forty-second entry, or nil if absent.
+      def forty_two = self[41]
+
+      # @!macro active_support
+      # @return [BasicObject, nil] The third entry from the end, or nil if absent.
+      def third_to_last = self[-3]
+
+      # @!macro active_support
+      # @return [BasicObject, nil] The second entry from the end, or nil if absent.
+      def second_to_last = self[-2]
+
+      # @!macro active_support
+      # Copy entries using ActiveSupport's deep-copy rules and the Vector's storage rules.
+      # Strict Vectors reject deep copies that are not shareable.
+      # @return [Vector] An independent same-kind Vector with deeply copied entries.
+      def deep_dup = map(&:deep_dup)
+
+      # @!macro active_support
+      # @return [Vector] Entries for which `blank?` is false, excluding nil and false.
+      def compact_blank = reject(&:blank?)
+
+      # @!macro active_support
+      # Extract keys from each entry in a snapshot.
+      # Extracted values follow the receiver's storage rules and transfer mode.
+      # @param keys [Array<BasicObject>] Keys passed to each entry's `[]` method.
+      # @return [Vector] Values for one key, or Vector rows for multiple keys.
+      def pluck(*keys)
+        return map { |entry| entry[keys.first] } unless keys.length > 1
+        map { |entry| build_derived_values(keys.map { |key| entry[key] }) }
+      end
+
+      # @!macro active_support
+      # Extract keys from the first entry in a snapshot.
+      # @param keys [Array<BasicObject>] Keys passed to the first entry's `[]` method.
+      # @return [BasicObject, Vector, nil] One value, a Vector for multiple keys, or nil if empty.
+      def pick(*keys)
+        snapshot = internal_vector.snapshot
+        return if snapshot.empty?
+        entry = logical_value(snapshot.first)
+        return entry[keys.first] unless keys.length > 1
+        build_derived_values(keys.map { |key| entry[key] })
+      end
+
+      # @!macro active_support
+      # Order a snapshot by the keys in series, preserving retained entries.
+      # @param key [Symbol, #to_proc] The method or callable used to extract ordering keys.
+      # @param series [Array] The desired order of keys.
+      # @param filter [Boolean] Whether to omit entries whose keys are absent from series.
+      # @return [Vector] The ordered entries. Repeated keys repeat their groups when filtering.
+      def in_order_of(key, series, filter: true)
+        snapshot = internal_vector.snapshot
+        logical = snapshot.map { logical_value(it) }
+        result = logical.in_order_of(key, series, filter:)
+        build_derived_from_logical(result, snapshot, logical)
+      end
+
+      # @!macro active_support
+      # Find the minimum extracted value without storing intermediate results in a Vector.
+      # @param key [Symbol, #to_proc] The method or callable used to extract comparison values.
+      # @return [BasicObject, nil] The minimum, or nil if empty.
+      def minimum(key) = to_a.minimum(key)
+
+      # @!macro active_support
+      # Find the maximum extracted value without storing intermediate results in a Vector.
+      # @param key [Symbol, #to_proc] The method or callable used to extract comparison values.
+      # @return [BasicObject, nil] The maximum, or nil if empty.
+      def maximum(key) = to_a.maximum(key)
+
+      # @!macro active_support
+      # Divide a snapshot into a requested number of Vector groups.
+      # @param number [Integer] The number of groups, following ActiveSupport's validation rules.
+      # @param fill_with [BasicObject] The padding value. False disables padding.
+      # @yield [group] Optionally visit each group after grouping the snapshot.
+      # @yieldparam group [Vector] A same-kind Vector containing one group.
+      # @yieldreturn [void] The result is ignored.
+      # @return [Vector] A Vector of groups, whether or not a block is supplied.
+      def in_groups(number, fill_with = nil)
+        groups = active_support_groups(:in_groups, number, fill_with)
+        result = build_derived_values(groups.map { build_derived_vector(it) })
+        result.each { yield it } if block_given?
+        result
+      end
+
+      # @!macro active_support
+      # Divide a snapshot into Vector groups with a maximum size.
+      # @param number [Integer] The positive group size.
+      # @param fill_with [BasicObject] The padding value. False disables padding.
+      # @yield [group] Optionally visit each group in the snapshot.
+      # @yieldparam group [Vector] A same-kind Vector containing one group.
+      # @yieldreturn [void] The result is ignored.
+      # @return [Vector, self] Groups without a block. With a block, the padded snapshot or self if padding is disabled.
+      def in_groups_of(number, fill_with = nil)
+        padding = fill_with != false
+        groups = active_support_groups(:in_groups_of, number, fill_with)
+        return build_derived_values(groups.map { build_derived_vector(it) }) unless block_given?
+        groups.each { yield build_derived_vector(it) }
+        padding ? build_derived_vector(groups.flatten(1)) : self
+      end
+
+      # @!macro active_support
+      # Split a snapshot at matching entries, omitting the separators.
+      # @param value [BasicObject] The separator compared with `==`, ignored when a block is supplied.
+      # @yield [entry] Optionally identify separator entries.
+      # @yieldparam entry [BasicObject] The current logical entry.
+      # @yieldreturn [BasicObject] A truthy value to split at this entry.
+      # @return [Vector] A Vector of Vector groups, including empty groups between adjacent separators.
+      def split(value = nil)
+        groups = internal_vector.snapshot.split do |stored|
+          entry = logical_value(stored)
+          block_given? ? yield(entry) : array_value_equal?(entry, value)
+        end
+        build_derived_values(groups.map { build_derived_vector(it) })
+      end
+
+      # @!macro active_support
+      # Convert a snapshot to ActiveSupport's explicit JSON representation.
+      # @param options [Hash, nil] Options passed to each entry's JSON conversion.
+      # @return [Array] The JSON-compatible values.
+      def as_json(options = nil) = to_a.as_json(options)
+
+      # @!macro active_support
+      # @return [String] The snapshot's URL parameter representation, joined with slashes.
+      def to_param = to_a.to_param
+
+      # @!macro active_support
+      # @param key [String] The query parameter name.
+      # @return [String] The encoded query string for the snapshot.
+      def to_query(key) = to_a.to_query(key)
+
+      # @!macro active_support
+      # Format a snapshot as a sentence using ActiveSupport's connectors and locale.
+      # @param options [Hash] Connector and locale options accepted by Array#to_sentence.
+      # @return [String] The formatted sentence.
+      def to_sentence(options = {}) = to_a.to_sentence(options)
+
+      # @!macro active_support
+      # Format a snapshot, optionally as a database ID list.
+      # @param format [Symbol] Use :db for comma-separated IDs, or :default for Array formatting.
+      # @return [String] The formatted snapshot.
+      def to_fs(format = :default) = to_a.to_fs(format)
+      alias to_formatted_s to_fs
+
+      # @!macro active_support
+      # Serialize a logical snapshot with ActiveSupport's Array XML conversion.
+      # Requires ActiveSupport's optional Builder dependency, as Array#to_xml does.
+      # @param options [Hash] XML options, including root, children, builder, and indentation.
+      # @yield [builder] Optionally append XML inside a nonempty collection's root element.
+      # @yieldparam builder [Builder::XmlMarkup] The XML builder used for serialization.
+      # @yieldreturn [void] The result is ignored.
+      # @return [String] The generated XML.
+      def to_xml(options = {}, &) = to_a.to_xml(options, &)
+
+      # @!macro active_support
+      # Create ActiveSupport's specialized query wrapper from a logical snapshot.
+      # @return [ActiveSupport::ArrayInquirer] An Array wrapper supporting predicate methods.
+      def inquiry = to_a.inquiry
+
+      private
+
+      def active_support_groups(method, number, fill_with)
+        marker = Object.new
+        groups = internal_vector.snapshot.public_send(method, number, fill_with == false ? false : marker)
+        stored_fill = UNDEFINED
+        groups.each do |group|
+          group.map! do |entry|
+            next entry unless entry.equal?(marker)
+            stored_fill = derived_storage(fill_with) if stored_fill.equal?(UNDEFINED)
+            stored_fill
+          end
+        end
+        groups
+      end
+    end
+  end
+end

data/lib/farce/integrations/active_support.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+require "farce"
+require "active_support"
+require "active_support/core_ext"
+
+Dir.glob("active_support/*.rb", base: __dir__) { require_relative it }

data/lib/farce/integrations/activesupport.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+require_relative "active_support"

data/lib/farce/integrations/bson.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group BSON Integration
+require "farce"
+require "bson"
+
+module Farce
+  class Abstract::Vector
+    # @note This method is only available if BSON has been loaded.
+    # Serialize a snapshot using BSON's array representation.
+    # Nested value wrappers are read before encoding their BSON types and payloads.
+    # @param buffer [BSON::ByteBuffer] An optional buffer to append to.
+    # @return [BSON::ByteBuffer] The buffer containing the encoded array.
+    def to_bson(buffer = ::BSON::ByteBuffer.new) = to_bson_normalized_value.to_bson(buffer)
+
+    # @note This method is only available if BSON has been loaded.
+    # Identify this value as a BSON array when embedded in a document or array.
+    # @return [String] The BSON array type byte.
+    def bson_type = ::BSON::Array::BSON_TYPE
+
+    # @note This method is only available if BSON has been loaded.
+    # Return a snapshot with nested values normalized by BSON.
+    # @return [Array] The normalized array.
+    def to_bson_normalized_value = to_a.to_bson_normalized_value
+
+    # @overload as_extended_json(**options)
+    #   @note This method is only available if BSON has been loaded.
+    #   Represent a snapshot as Extended JSON, forwarding BSON's format options.
+    #   @param options [Hash] Options forwarded to Array#as_extended_json.
+    #   @return [Array] The Extended JSON representation.
+    def as_extended_json(**) = to_a.as_extended_json(**)
+  end
+
+  class Abstract::Map
+    # @note This method is only available if BSON has been loaded.
+    # Serialize current entries as a BSON document.
+    # Nested value wrappers are read before encoding their BSON types and payloads.
+    # @param buffer [BSON::ByteBuffer] An optional buffer to append to.
+    # @return [BSON::ByteBuffer] The buffer containing the encoded document.
+    def to_bson(buffer = ::BSON::ByteBuffer.new) = to_bson_normalized_value.to_bson(buffer)
+
+    # @note This method is only available if BSON has been loaded.
+    # Identify this value as a BSON document when embedded in a document or array.
+    # @return [String] The BSON document type byte.
+    def bson_type = ::BSON::Hash::BSON_TYPE
+
+    # @note This method is only available if BSON has been loaded.
+    # Return current entries with keys and nested values normalized by BSON.
+    # @return [BSON::Document] The normalized document.
+    def to_bson_normalized_value = to_h.to_bson_normalized_value
+
+    # @overload as_extended_json(**options)
+    #   @note This method is only available if BSON has been loaded.
+    #   Represent current entries as Extended JSON, forwarding BSON's format options.
+    #   @param options [Hash] Options forwarded to Hash#as_extended_json.
+    #   @return [Hash] The Extended JSON representation.
+    def as_extended_json(**) = to_h.as_extended_json(**)
+  end
+
+  class Abstract::Set
+    # @note This method is only available if BSON has been loaded.
+    # Serialize current members using BSON's array representation.
+    # Nested value wrappers are read before encoding their BSON types and payloads.
+    # @param buffer [BSON::ByteBuffer] An optional buffer to append to.
+    # @return [BSON::ByteBuffer] The buffer containing the encoded array.
+    def to_bson(buffer = ::BSON::ByteBuffer.new) = to_bson_normalized_value.to_bson(buffer)
+
+    # @note This method is only available if BSON has been loaded.
+    # Identify this value as a BSON array when embedded in a document or array.
+    # @return [String] The BSON array type byte.
+    def bson_type = ::BSON::Array::BSON_TYPE
+
+    # @note This method is only available if BSON has been loaded.
+    # Return current members with nested values normalized by BSON.
+    # @return [Array] The normalized array.
+    def to_bson_normalized_value = to_a.to_bson_normalized_value
+
+    # @overload as_extended_json(**options)
+    #   @note This method is only available if BSON has been loaded.
+    #   Represent current members as Extended JSON, forwarding BSON's format options.
+    #   @param options [Hash] Options forwarded to Array#as_extended_json.
+    #   @return [Array] The Extended JSON representation.
+    def as_extended_json(**) = to_a.as_extended_json(**)
+  end
+
+  module Internal::ValueSerialization
+    # @note This method is only available if BSON has been loaded.
+    # Serialize the current stored value using its BSON representation.
+    # Use BSON::Document.new when embedding value wrappers in ordinary Ruby hashes.
+    # @param buffer [BSON::ByteBuffer] An optional buffer to append to.
+    # @return [BSON::ByteBuffer] The buffer containing the encoded value.
+    def to_bson(buffer = ::BSON::ByteBuffer.new) = to_bson_normalized_value.to_bson(buffer)
+
+    # @note This method is only available if BSON has been loaded.
+    # Read the stored value once and normalize it for BSON encoding.
+    # @return [Object] The normalized current value.
+    def to_bson_normalized_value = value.to_bson_normalized_value
+
+    # @overload as_extended_json(**options)
+    #   @note This method is only available if BSON has been loaded.
+    #   Represent the current value as Extended JSON, forwarding BSON's format options.
+    #   @param options [Hash] Options forwarded to the value's as_extended_json.
+    #   @return [Object] The Extended JSON representation.
+    def as_extended_json(**) = value.as_extended_json(**)
+  end
+end

data/lib/farce/integrations/cbor.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group CBOR Integration
+require "farce"
+require "cbor"
+
+module Farce
+  class Abstract::Vector
+    # @overload to_cbor(*arguments)
+    #   @note This method is only available if CBOR has been loaded.
+    #   @note On CRuby, CBOR's native encoder must run in the main Ractor.
+    #   Serialize a snapshot as a CBOR array.
+    #   @example
+    #     CBOR.decode(Farce::Vector.new([1, false]).to_cbor) # => [1, false]
+    #   @param arguments [Array<Object>] Arguments forwarded to Array#to_cbor.
+    #   @return [String, ::CBOR::Packer, nil] Encoded bytes, the supplied packer, or nil when writing to IO.
+    def to_cbor(...) = to_a.to_cbor(...)
+  end
+
+  class Abstract::Map
+    # @overload to_cbor(*arguments)
+    #   @note This method is only available if CBOR has been loaded.
+    #   @note On CRuby, CBOR's native encoder must run in the main Ractor.
+    #   Serialize current entries as a CBOR map.
+    #   @param arguments [Array<Object>] Arguments forwarded to Hash#to_cbor.
+    #   @return [String, ::CBOR::Packer, nil] Encoded bytes, the supplied packer, or nil when writing to IO.
+    def to_cbor(...) = to_h.to_cbor(...)
+  end
+
+  class Abstract::Set
+    # @overload to_cbor(*arguments)
+    #   @note This method is only available if CBOR has been loaded.
+    #   @note On CRuby, CBOR's native encoder must run in the main Ractor.
+    #   Serialize current members as a CBOR array.
+    #   @param arguments [Array<Object>] Arguments forwarded to Array#to_cbor.
+    #   @return [String, ::CBOR::Packer, nil] Encoded bytes, the supplied packer, or nil when writing to IO.
+    def to_cbor(...) = to_a.to_cbor(...)
+  end
+
+  module Internal::ValueSerialization
+    # @overload to_cbor(*arguments)
+    #   @note This method is only available if CBOR has been loaded.
+    #   @note On CRuby, CBOR's native encoder must run in the main Ractor.
+    #   Serialize the current value using its CBOR representation.
+    #   @param arguments [Array<Object>] Arguments forwarded to the value's to_cbor.
+    #   @return [String, ::CBOR::Packer, nil] Encoded bytes, the supplied packer, or nil when writing to IO.
+    def to_cbor(...) = value.to_cbor(...)
+  end
+end