farce 0.0.1.alpha2-x86-linux-gnu

data/lib/farce/integrations/json.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+require "farce"
+require "json" unless defined?(JSON::State)
+require_relative "shared/to_json"

data/lib/farce/integrations/msgpack.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group ActiveSupport Integration
+require "farce"
+require "msgpack"
+
+module Farce
+  class Abstract::Vector
+    # Serialize a snapshot as a MessagePack array.
+    # @note This method is only available if MessagePack has been loaded.
+    # @overload to_msgpack(*arguments)
+    #   @param arguments [Array<Object>] Arguments forwarded to Array#to_msgpack.
+    # @return [String, ::MessagePack::Packer] The encoded bytes or supplied packer.
+    def to_msgpack(...) = to_a.to_msgpack(...)
+  end
+
+  class Abstract::Map
+    # Serialize current entries as a MessagePack map.
+    # @note This method is only available if MessagePack has been loaded.
+    # @overload to_msgpack(*arguments)
+    #   @param arguments [Array<Object>] Arguments forwarded to Hash#to_msgpack.
+    # @return [String, ::MessagePack::Packer] The encoded bytes or supplied packer.
+    def to_msgpack(...) = to_h.to_msgpack(...)
+  end
+
+  class Abstract::Set
+    # Serialize current members as a MessagePack array.
+    # @note This method is only available if MessagePack has been loaded.
+    # @overload to_msgpack(*arguments)
+    #   @param arguments [Array<Object>] Arguments forwarded to Array#to_msgpack.
+    # @return [String, ::MessagePack::Packer] The encoded bytes or supplied packer.
+    def to_msgpack(...) = to_a.to_msgpack(...)
+  end
+
+  module Internal::ValueSerialization
+    # Serialize the current value as its primitive MessagePack equivalent.
+    # @note This method is only available if MessagePack has been loaded.
+    # @overload to_msgpack(*arguments)
+    #   @param arguments [Array<Object>] Arguments forwarded to the value's to_msgpack.
+    # @return [String, ::MessagePack::Packer] The encoded bytes or supplied packer.
+    def to_msgpack(...) = value.to_msgpack(...)
+  end
+
+  # @note This module is only available if MessagePack has been loaded.
+  module MessagePack
+    # Default mapping used by {.factory}.
+    DEFAULT_TYPES = { Vector => 0, Map => 1, Counter => 2, Flag => 3, Atom => 4, Set => 5 }.freeze
+
+    extend self
+
+    # Build a factory that restores registered Farce classes.
+    # Use the same type IDs when writing and reading data.
+    # @note This method is only available if MessagePack has been loaded.
+    # @param types [Hash{Class => Integer}] Classes and their application extension IDs.
+    # @return [::MessagePack::Factory] An independent factory.
+    # @!scope class
+    def factory(types: DEFAULT_TYPES)
+      result = ::MessagePack::Factory.new
+      types.each { |klass, type| register_type(result, type, klass) }
+      result
+    end
+
+    # Register a Farce class on an application-owned factory.
+    # Values use the same factory recursively, including nested custom types.
+    # Source configuration is replaced by the supplied constructor options.
+    # Counters also retain their initial value for reset.
+    # @note This method is only available if MessagePack has been loaded.
+    # @param factory [::MessagePack::Factory] The factory to configure.
+    # @param type [Integer] An unused application extension ID from 0 through 127.
+    # @param klass [Class] A concrete Farce vector, map, set, counter, flag, or atom class.
+    # @param options [Hash{Symbol => Object}] Constructor options for restored objects.
+    # @return [::MessagePack::Factory] The supplied factory.
+    # @raise [ArgumentError] If the class is unsupported or the ID or class is already registered.
+    # @!scope class
+    def register_type(factory, type, klass, **)
+      reader = primitive_reader(klass)
+      unless type.is_a?(Integer) && (0..127).cover?(type)
+        raise ArgumentError, "MessagePack extension IDs must be integers from 0 through 127"
+      end
+      if factory.registered_types.any? { it[:type] == type || it[:class] == klass }
+        raise ArgumentError, "MessagePack extension ID or class is already registered"
+      end
+
+      counter = klass <= Abstract::Counter
+      factory.register_type(type, klass,
+        packer:    lambda { |object, packer|
+          packer.write(object.initial) if counter
+          packer.write(object.public_send(reader))
+        },
+        unpacker:  lambda { |unpacker|
+          object = klass.new(unpacker.read, **)
+          object.value = unpacker.read if counter
+          object
+        },
+        recursive: true)
+      factory
+    end
+
+    private
+
+    def primitive_reader(klass)
+      raise ArgumentError, "expected a concrete Farce class" unless klass.is_a?(Class)
+      return :to_a if klass <= Abstract::Vector || klass <= Abstract::Set
+      return :to_h if klass <= Abstract::Map
+      return :value if klass <= Abstract::Counter || klass <= Abstract::Flag || klass <= Abstract::Atom
+
+      raise ArgumentError, "unsupported Farce class: #{klass}"
+    end
+  end
+end

data/lib/farce/integrations/oj.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group Oj Integration
+require "farce"
+require "oj" unless defined?(Oj::VERSION)
+
+require "json" unless [].respond_to?(:to_json)
+require_relative "shared/to_json"
+
+module Farce
+  # Object-mode reconstruction for Oj.
+  # @api private
+  module Oj
+    # @api private
+    Constructor = Data.define(:klass, :options, :counter) do
+      def call(value, current = nil)
+        object = klass.new(value, **options)
+        object.value = current if counter
+        object
+      end
+    end
+    private_constant :Constructor
+
+    extend self
+
+    # Register a concrete class for Oj object-mode round trips.
+    # Registrations are process-global. Configure them before starting concurrent serialization.
+    # Repeated registration replaces the previous reconstruction settings for the class.
+    # Source settings are replaced by the supplied options. Counters retain their initial value.
+    # Constructor options are copied and made Ractor-shareable.
+    # Reading move-backed contents can transfer ownership to the serializing Ractor.
+    # @param klass [Class] A named Farce vector, map, set, counter, flag, or atom class.
+    # @param options [Hash{Symbol => Object}] Constructor options for restored objects.
+    # @return [Class] The registered class.
+    # @raise [ArgumentError] If the class is unsupported or anonymous.
+    # @raise [Ractor::IsolationError] If registration is attempted outside the main native Ractor.
+    # @!scope class
+    def register_type(klass, **options)
+      if Internal.native_ractors? && !Ractor.main?
+        raise Ractor::IsolationError, "register Oj types in the main Ractor before concurrent use"
+      end
+      unless klass.is_a?(Class) && klass.name && !klass.name.start_with?("Farce::Abstract::")
+        raise ArgumentError, "expected a named concrete Farce class"
+      end
+
+      reader = if klass <= Abstract::Vector || klass <= Abstract::Set
+                 :to_a
+               elsif klass <= Abstract::Map
+                 :to_h
+               elsif klass <= Abstract::Counter || klass <= Abstract::Flag || klass <= Abstract::Atom
+                 :value
+               else
+                 raise ArgumentError, "unsupported Farce class: #{klass}"
+               end
+      counter = klass <= Abstract::Counter
+      constructor = Constructor.new(klass, Ractor.make_shareable(options, copy: true), counter)
+      Ractor.make_shareable(constructor)
+      members = counter ? [:initial, reader] : [reader]
+      ::Oj.register_odd(klass, constructor, :call, *members)
+      klass
+    end
+  end
+end
+
+[Farce::Vector, Farce::Map, Farce::Set, Farce::Counter, Farce::Flag, Farce::Atom].each do |klass|
+  Farce::Oj.register_type(klass)
+end

data/lib/farce/integrations/psych.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group Psych Integration
+require "farce"
+require "psych" unless defined?(Psych::Coder)
+
+module Farce
+  class Abstract::Map
+    # @api private
+    # Called by Psych for generating YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [Psych::Coder] The coder containing the serialized fields.
+    def encode_with(coder)
+      coder["entries"]                    = to_h
+      coder["compare_values_by_identity"] = compare_values_by_identity?
+      coder["compare_keys_by_identity"]   = compare_keys_by_identity?
+      normalizer = instance_variable_get(:@key_normalizer)
+      coder["normalize_keys"] = Internal::KeyNormalizer.dump(normalizer) if normalizer
+      coder["scope"] = scope if respond_to?(:scope)
+      coder
+    end
+
+    # @api private
+    # Called by Psych when parsing YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [void]
+    def init_with(coder)
+      options = coder.map.except("entries").transform_keys(&:to_sym)
+      if options.key?(:normalize_keys)
+        options[:normalize_keys] =
+          Internal::KeyNormalizer.restore(options[:normalize_keys])
+      end
+      initialize(coder["entries"], **options)
+    end
+  end
+
+  class Abstract::BoundedMap
+    # @api private
+    # Called by Psych for generating YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [Psych::Coder] The coder containing the serialized fields.
+    def encode_with(coder) = super.tap { it["max_size"] = max_size }
+  end
+
+  module Internal::ValueSerialization
+    # @api private
+    # Called by Psych for generating YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [Psych::Coder] The coder containing the serialized fields.
+    def encode_with(coder)
+      coder["value"] = value
+      coder["scope"] = scope if respond_to?(:scope)
+      coder
+    end
+
+    # @api private
+    # Called by Psych when parsing YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [void]
+    def init_with(coder)
+      options = coder.map.except("value").transform_keys(&:to_sym)
+      initialize(coder["value"], **options)
+    end
+  end
+
+  class Abstract::Atom
+    # @api private
+    # Called by Psych for generating YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [Psych::Coder] The coder containing the serialized fields.
+    def encode_with(coder)
+      super
+      coder["compare_by_identity"] = compare_by_identity?
+      coder["shareable"]           = Ractor.shareable?(coder["value"])
+      coder
+    end
+
+    # @api private
+    # Restore the value and its shareability when parsing YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [void]
+    def init_with(coder)
+      value   = coder["value"]
+      value   = Ractor.make_shareable(value) if coder["shareable"]
+      options = coder.map.except("value", "shareable").transform_keys(&:to_sym)
+      initialize(value, **options)
+    end
+  end
+
+  module Abstract::Counter
+    # @api private
+    # Called by Psych for generating YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [Psych::Coder] The coder containing the serialized fields.
+    def encode_with(coder)
+      super
+      coder["initial"] = initial
+      coder
+    end
+
+    # @api private
+    # Called by Psych when parsing YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [void]
+    def init_with(coder)
+      options = coder.map.except("value", "initial").transform_keys(&:to_sym)
+      initialize(coder["initial"], **options)
+      self.value = coder["value"]
+    end
+  end
+
+  class Atom
+    # @api private
+    # Called by Psych for generating YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [Psych::Coder] The coder containing the serialized fields.
+    def encode_with(coder)
+      super
+      coder["mode"] = mode
+      coder
+    end
+  end
+
+  class Abstract::Set
+    # @api private
+    # Called by Psych for generating YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [Psych::Coder] The coder containing the set representation.
+    def encode_with(coder)
+      coder["entries"] = each_stored.map do |key, stored|
+        element        = public_stored(key, stored)
+        entry          = {
+          "value"     => element,
+          "shareable" => Ractor.shareable?(element),
+        }
+        if value_modes?
+          entry["identity"] = identity_storage_key?(key)
+          entry["snapshot"] = key unless entry["identity"]
+          entry["mode"]     = stored_mode(stored)
+        end
+        entry
+      end
+      coder["compare_by_identity"] = compare_by_identity?
+      coder["frozen"]              = frozen?
+      coder["mode"]                = mode if respond_to?(:mode)
+      coder["scope"]               = scope if respond_to?(:scope)
+      coder["normalize"]           = Internal::KeyNormalizer.dump(@normalizer) if @normalizer
+      coder
+    end
+
+    # @api private
+    # Called by Psych when parsing YAML.
+    # @param coder [Psych::Coder] The YAML representation.
+    # @return [self] The restored set.
+    def init_with(coder)
+      options             = { compare_by_identity: coder["compare_by_identity"] }
+      options[:mode]      = coder["mode"].to_sym                                if coder["mode"]
+      options[:scope]     = coder["scope"].to_sym                               if coder["scope"]
+      options[:normalize] = Internal::KeyNormalizer.restore(coder["normalize"]) if coder.map.key?("normalize")
+      entries             = coder["entries"]
+
+      if coder["mode"] && value_modes?
+        initialize(nil, **options)
+        entries.each { restore_yaml_entry(it) }
+      else
+        values = entries.map { restore_yaml_value(it) }
+        initialize(values, **options)
+      end
+
+      freeze if coder["frozen"]
+      self
+    end
+
+    private
+
+    def restore_yaml_entry(entry)
+      value   = restore_yaml_value(entry)
+      key     = entry["identity"] ? comparison_key_for_canonical(value) : Ractor.make_shareable(entry["snapshot"])
+      mode    = entry["mode"]&.to_sym
+      payload = @manager.wrap(value, mode:)
+      add_stored(key, StoredEntry.new(@manager, payload))
+    end
+
+    def restore_yaml_value(entry)
+      value = entry["value"]
+      entry["shareable"] ? Ractor.make_shareable(value) : value
+    end
+  end
+end

data/lib/farce/integrations/ractor-sharing.rb

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

data/lib/farce/integrations/ractor-tmvar.rb

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

data/lib/farce/integrations/ractor_sharing.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group ractor-sharing Integration
+require "farce"
+require "ractor/tvar"
+require "ractor/lockvar"
+require "ractor/lockhash"
+require "ractor/keylockhash"
+require "ractor/active_object"
+require "ractor/actor_hash"
+
+module Farce
+  module Integrations
+    # @api private
+    module RactorSharing
+      # The private marker is published in the same STM commit as all TVars.
+      # It distinguishes a failed STM attempt from a post-publication exception.
+      class Commit
+        def initialize(entries)
+          @entries = entries
+          @marker = ::Ractor::TVar.new(false)
+        end
+
+        def committed? = @marker.value
+
+        def commit
+          ::Ractor.atomically do
+            @entries.each do |entry|
+              unless Internal::PortableTransaction.same?(entry.source.value, entry.baseline)
+                raise Internal::TransactionConflict, "TVar changed"
+              end
+            end
+            # Validate the complete read set before staging any writes.
+            @entries.each { it.source.value = it.value if it.dirty? } # rubocop:disable Style/CombinableLoops
+            @marker.value = true
+          end
+        end
+      end
+
+      class Entry
+        attr_reader :source, :baseline
+        attr_accessor :value
+
+        def initialize(source)
+          # atomically is nestable, so it could return before actual publication.
+          # Test a private slot before taking a snapshot or any Farce reservations.
+          probe = ::Ractor::TVar.new(false)
+          begin
+            probe.value = false
+          rescue ::Ractor::TransactionError
+            # Expected outside STM. All publication belongs to our commit step.
+          else
+            raise ArgumentError, "Farce transactions with TVars cannot run inside Ractor.atomically"
+          end
+          @source = source
+          @value = @baseline = ::Ractor.atomically { source.value }
+          @dirty = false
+        end
+
+        def working = self
+        def write! = @dirty = true
+        def dirty? = @dirty
+        def commit_group = Commit
+      end
+    end
+  end
+
+  class Transaction
+    # A Ractor::TVar staged alongside ordinary Farce participants.
+    #
+    # Only the commit step enters Ractor.atomically. Conflicts retry the Farce
+    # attempt. Values are made shareable when assigned, matching TVar's setter.
+    # Mutating a contained object directly is a side effect of the attempt.
+    #
+    # Run the Farce transaction outside an enclosing Ractor.atomically block.
+    # Writable Concurrent::TVar participants cannot join this commit step.
+    #
+    # @example Transfer between a TVar and an Atom
+    #   available = Ractor::TVar.new(10)
+    #   received  = Farce::Strict::Atom.new(0)
+    #   Farce.transaction do |tx|
+    #     tx[available].value -= 3
+    #     tx[received].value += 3
+    #   end
+    class RactorTVar
+      include Wrapper
+
+      # @return [Object] the value staged in this attempt
+      def value = access { @working.value }
+
+      # Stage a shareable replacement.
+      # @param value [Object] the replacement value
+      # @return [Object] the shareable replacement
+      def value=(value)
+        # Can't use #write, as a TVar's Ruby facade is always frozen
+        access do
+          @entry.write!
+          @working.value = ::Ractor.make_shareable(value)
+        end
+      end
+
+      private
+
+      def enlist(backend) = @transaction.enlist(backend) { Integrations::RactorSharing::Entry.new(it) }
+    end
+  end
+
+  Transaction.define(::Ractor::TVar) do |object, transaction|
+    Farce::Transaction::RactorTVar.new(transaction, object, object)
+  end
+
+  [::Ractor::TVar, ::Ractor::LockVar, ::Ractor::LockHash, ::Ractor::KeyLockHash].each do |klass|
+    klass.include(Internal::Noncopyable) unless klass < Internal::Noncopyable
+  end
+
+  [::Ractor::LockHash, ::Ractor::KeyLockHash].each do |klass|
+    Internal::Converter.define(klass, :Map) do |instance, hash|
+      hash.keys.each do |key| # rubocop:disable Style/HashEachMethods
+        value = hash.fetch(key, UNDEFINED)
+        instance[key] = convert(value) unless UNDEFINED.equal?(value)
+      end
+    end
+  end
+
+  Walker.define(::Ractor::TVar) do |object, walker|
+    walker.update(object, [object.value]) do |target, results|
+      ::Ractor.atomically { target.value = results.first unless target.value.equal?(results.first) }
+      target
+    end
+  end
+
+  Walker.define(::Ractor::LockVar) do |object, walker|
+    walker.update(object, [object.value]) do |target, results|
+      target.update { |value| value.equal?(results.first) ? value : results.first }
+      target
+    end
+  end
+
+  Walker.define(::Ractor::LockHash) do |object, walker|
+    values = object.to_h.flat_map { |key, value| [key, value] }
+    walker.update(object, values, hash_keys: true, key_stride: 2) do |target, results|
+      results.each_slice(2) { |key, _| walker.check_hash_key(key) }
+      target.synchronize do
+        values.each_slice(2).with_index do |(key, _), index|
+          key_result = results[index * 2]
+          target.delete(key) unless key.equal?(key_result)
+        end
+        results.each_slice(2) { |key, value| target[key] = value }
+      end
+      target
+    end
+  end
+
+  Walker.define(::Ractor::KeyLockHash) do |object, walker|
+    values = object.to_h.flat_map { |key, value| [key, value] }
+    walker.update(object, values, hash_keys: true, key_stride: 2) do |target, results|
+      results.each_slice(2) { |key, _| walker.check_hash_key(key) }
+      values.each_slice(2).with_index do |(key, _), index|
+        key_result = results[index * 2]
+        target.delete(key) unless key.equal?(key_result)
+      end
+      results.each_slice(2) { |key, value| target[key] = value }
+      target
+    end
+  end
+
+  Walker.define(::Ractor::ActiveObject::Proxy) do |object, _walker|
+    object
+  end
+end

data/lib/farce/integrations/ractor_tmvar.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group ractor-tmvar Integration
+require "farce/integrations/ractor_sharing"
+require "ractor/tmvar"
+
+module Farce
+  class Transaction
+    # A Ractor::TMVar staged alongside TVars and Farce participants.
+    #
+    # Take, put, and swap operate on the value staged in this attempt.
+    # An empty read, take, or swap, or a put into a full TMVar fails the
+    # attempt. Farce.transaction retries these conditions within its retry limit.
+    # The try_* methods return nil or false without failing the attempt.
+    # Assigned values are made shareable, matching Ractor::TVar's setter.
+    #
+    # Run outside Ractor.atomically, as required by {RactorTVar}.
+    # Calls from other Ractors require Ractor-safe TVar methods from ractor-sharing.
+    #
+    # @example Transfer from a TMVar to an Atom
+    #   pending  = Ractor::TMVar.new(10)
+    #   received = Farce::Strict::Atom.new(0)
+    #   Farce.transaction do |tx|
+    #     tx[received].value += tx[pending].take
+    #   end
+    class RactorTMVar < ::Ractor::TMVar
+      include Wrapper
+
+      # Bind the TMVar's underlying TVar to this attempt's shared snapshot.
+      # @param transaction [Transaction] the current attempt
+      # @param object [Ractor::TMVar] the participant
+      def initialize(transaction, object)
+        super
+        # TMVar exposes no accessor for its storage. Reuse the TVar wrapper
+        # so explicit enrollment of that same TVar shares all staged changes.
+        compose(tvar: object.instance_variable_get(:@tvar))
+      end
+
+      Wrapper.inherit(self, :take, :try_take, :read, :try_read, :put, :try_put, :empty?, :swap)
+
+      private
+
+      # Translate STM retry conditions before Wrapper marks other exceptions
+      # as non-retryable. No upstream STM block runs during staged operations.
+      def access
+        super do
+          yield
+        rescue ::Ractor::RetryTransaction
+          raise Internal::TransactionConflict, "TMVar is empty or full"
+        end
+      end
+    end
+  end
+
+  Transaction.define(Transaction::RactorTMVar) do |object, transaction|
+    object.transaction_wrapper(transaction)
+  end
+
+  Transaction.define(::Ractor::TMVar) do |object, transaction|
+    Farce::Transaction::RactorTMVar.new(transaction, object)
+  end
+end

data/lib/farce/integrations/shared/to_json.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group JSON Integration
+module Farce
+  class Abstract::Vector
+    # Serialize a logical snapshot as a JSON Array.
+    # @note This method is only available if a supported JSON library has been loaded.
+    # @overload to_json(*arguments)
+    #   @param arguments [Array<Object>] Arguments forwarded to Array#to_json.
+    #   @return [String] The generated JSON.
+    def to_json(...) = to_a.to_json(...)
+  end
+
+  class Abstract::Map
+    # Serialize current entries as a JSON object.
+    # @note This method is only available if a supported JSON library has been loaded.
+    # @overload to_json(*arguments)
+    #   @param arguments [Array<Object>] Arguments forwarded to Hash#to_json.
+    #   @return [String] The generated JSON.
+    def to_json(...) = to_h.to_json(...)
+  end
+
+  class Abstract::Set
+    # Serialize current members as a JSON Array.
+    # @note This method is only available if a supported JSON library has been loaded.
+    # @overload to_json(*arguments)
+    #   @param arguments [Array<Object>] Arguments forwarded to Array#to_json.
+    #   @return [String] The generated JSON.
+    def to_json(...) = to_a.to_json(...)
+  end
+
+  module Internal::ValueSerialization
+    # Serialize the current value as its primitive JSON equivalent.
+    # @note This method is only available if a supported JSON library has been loaded.
+    # @overload to_json(*arguments)
+    #   @param arguments [Array<Object>] Arguments forwarded to the current value's to_json.
+    #   @return [String] The generated JSON.
+    def to_json(...) = value.to_json(...)
+  end
+end

data/lib/farce/integrations/sorted_set.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+# @!group SortedSet Integration
+require "farce"
+require "sorted_set"
+
+module Farce
+  Internal::Converter.define(::SortedSet, :SortedSet)
+end