farce 0.5.0-java → 0.6.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 565c706934f8c44d83e0e04621ba8f1750907cc4d36863e6cff44e5d7e60ba02
-  data.tar.gz: 8bf03ad5685afafa3fc22e96f8c393c01a7f06681054f9661adc86a2d9c131f1
+  metadata.gz: f4a0f5afb79dd6bc07800615fb635a4d27e43e86182ab8755e30acdf098a1b02
+  data.tar.gz: 5ac35e034510294a7ec161dd0b507dd08da1c1789163b15595d97066cacbe4d4
 SHA512:
-  metadata.gz: 4244dfd3d0e6f68cb8661f1861fffcbfdaf0890db3f6a56afb1b13809ea18e1186add54e95ed8ee156dd18f3eb0bd4fd6e9252a0e685bd2c5e276392add4167a
-  data.tar.gz: 431ed85187432bd10bcb34ad8128bae689a797390510fd5687c61bbee3ad2e781a6bfb638f7ad97185ac7366bda8cd6cd37af678555c8d23d3143bb9fc9b8886
+  metadata.gz: a49dbafabb7541750f63181bc3d0dd624e7ae65d6fdd1aaa1cbb24757e0ed21d0e8724faac9319a2eb629723616badde31de1598028381bb80cda3dca0a9fa99
+  data.tar.gz: 8319b420ec31b816c842be424a114fd37a37313200210e15e4c4a07c0ce931a757e77064d5967fddfccec519aa3eaec7ad4c7190f33e33cb6155c0da0f9143c1

data/CHANGELOG.md

@@ -6,6 +6,7 @@ Farce follows [Semantic Versioning 2.0](http://semver.org/). Any public method o
 
  Version                        | Date       | Important Changes
 --------------------------------|------------|--------------------------------------
+ [0.6.0](#farce-060-2026-11-04) | 2026-11-04 | Performance improvements, better counters, and `WeakCache`
  [0.5.0](#farce-050-2026-10-21) | 2026-10-21 | Publishers, memoization, pool and queue resizing, and better concurrent-ruby compatibility
  [0.4.1](#farce-041-2026-10-18) | 2026-10-18 | Include improved io_uring support in prebuilt Linux binaries
  [0.4.0](#farce-040-2026-10-16) | 2026-10-16 | Introduce `Farce::Backports`
@@ -15,6 +16,23 @@ Farce follows [Semantic Versioning 2.0](http://semver.org/). Any public method o
 
 ## Release History
 
+### Farce 0.6.0 (2026-11-04)
+
+#### Breaking Changes
+
+* `Counter` and `Local::Counter` arithmetic methods (`increment`, `add`, `decrement`, `subtract`, and `remove`) now return the integer produced by the atomic update instead of the counter. Use `number = counter.increment` to allocate sequence numbers without a separate read. Calls can no longer be chained.
+
+#### New Features
+
+* `Farce.dedup` can now deduplicate `Regexp`, `Range`, `Data`, and `SortedSet` instances.
+* `Farce::Walker` (and thus `Farce.freeze_graph`) correctly walk `Struct` and `Range` instances now.
+* Add `Farce::Strict::WeakCache`. It offers a subset of the API of `Farce::Strict::WeakValueMap`, but without its performance penalty on CRuby 3.x and 4.0 (on other Rubies, including CRuby 4.1, it's just a tiny wrapper around the well-performing `WeakValueMap`).
+
+#### Performance improvements
+
+* Faster construction of Map and Vector instances.
+* Speed up atoms and memoization.
+
 ### Farce 0.5.0 (2026-10-21)
 
 #### New Features

data/docs/modes.md

@@ -390,7 +390,7 @@ The same choices appear in several Farce APIs. Containers normally default to `:
 | `Farce::Exchanger` | `new`, `exchange` | The value offered to a partner. |
 | `Farce::WeakAtom` | `new`, `store`, `update`, and other replacement operations | Weakly held values. Supports only `:raise`, `:make_shareable`, and `:dedup`. Defaults to `:raise`. |
 | `Farce::Atom` | `new`, `store`, `swap`, `update`, and other replacement operations | The stored value. |
-| `Farce::Memoize` | `memoize`, `[]` | Memoized results with `scope: :global` (the default). With `weak: true`, supports only `:raise`, `:make_shareable`, and `:dedup`, and defaults to `:raise`. Other scopes ignore the mode. |
+| `Farce::Memoize` | `memoize`, `[]` | Memoized results with `scope: :global` (the default). `:strict` caches shareable results directly, including with `weak: true`. Weak memoization also accepts `:raise` (the default), `:make_shareable`, and `:dedup`. Other scopes ignore the mode. |
 | `Farce::Lazy`, `Farce::LazyRef` | `new` | The result computed once by the factory. |
 | `Farce::Task` | `new`, `schedule`, `try_schedule`, `in_parallel`, `on_main`, `add_argument` | Arguments and the successful result. `add_argument` overrides the mode for one argument. Scheduling can select local mode automatically. |
 | `Farce::Publisher`, `Farce::Unshared::Publisher`, `Farce::Local::Publisher` | `subscribe` with a block | Callback arguments and queued payloads. Defaults to `:smart` for `Publisher` and `:local` for its Unshared and Local variants. |

data/docs/utilities.md

@@ -59,6 +59,7 @@ Other classes Farce provides include:
 * `ThreadExecutor`: A [task executor](scheduling.md#scheduling-code) creating a new thread for each unit of work. Used on TruffleRuby.
 * `Walker`: A tool for walking a Ruby object tree.
 * `WeakValue`: A value object version of [`WeakRef`](shims.md#weakref). Allows handling references more explicitly, without automatic method delegation.
+* `Strict::WeakCache`: Ractor-shared weak maps are slow on CRuby before 4.1. `WeakCache` provides a faster alternative if entries aren't frequently garbage collected, but it does not allow deleting or replacing entries manually.
 
 In addition, Farce includes a range of error classes not listed here. Check the [API documentation](https://rkh.github.io/farce/) or [code base](https://github.com/rkh/farce/blob/main/lib/farce/error.rb) for these.
 

data/lib/farce/abstract/atom.rb

@@ -59,7 +59,11 @@ module Farce
       # @yield computes the value to store when the current value is nil
       # @yieldreturn [BasicObject, nil] the value to store
       # @return [BasicObject, nil] the current or newly stored value, or nil when the timeout expires
-      def store_if_absent(timeout: nil, &) = internal_atom.store_if_absent(timeout:, &)
+      def store_if_absent(timeout: nil, &)
+        return internal_atom.store_if_absent(&) if timeout.nil?
+
+        internal_atom.store_if_absent(timeout:, &)
+      end
 
       # Atomically replace the current value if it matches the expected value.
       # @param expected [BasicObject, nil] the value to compare with the current value

data/lib/farce/abstract/counter.rb

@@ -15,14 +15,15 @@ module Farce
     #   @return [Integer] The current value of the counter.
     #
     # @!method increment(by = 1)
-    #   Increment the counter by the given amount (default is 1).
+    #   Atomically increment the counter by the given amount (default is 1).
+    #   Use the returned integer to allocate a sequence number without a separate read.
     #   @param [Numeric, String, #to_int] by The amount, converted to an Integer.
-    #   @return [self] Returns self for chaining.
+    #   @return [Integer] The value produced by this atomic update.
     #
     # @!method decrement(by = 1)
-    #   Decrement the counter by the given amount (default is 1).
+    #   Atomically decrement the counter by the given amount (default is 1).
     #   @param [Numeric, String, #to_int] by The amount, converted to an Integer.
-    #   @return [self] Returns self for chaining.
+    #   @return [Integer] The value produced by this atomic update.
     module Counter
       include Internal::MarshalSupport::Counter
       include Internal::Copyable

data/lib/farce/abstract/molecule.rb

@@ -76,6 +76,20 @@ module Farce
       # @return [Boolean] the default comparison policy for new records
       def self.compare_by_identity? = false
 
+      # @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
+
       # @!visibility private
       def self.define_member(field)
         raise ArgumentError, "#{field.inspect} is not a valid field name" if field == :compare_by_identity
@@ -99,20 +113,6 @@ module Farce
       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

data/lib/farce/abstract/vector.rb

@@ -1390,7 +1390,7 @@ module Farce
 
       private
 
-      def normalize_vector_source(source) = source.is_a?(Integer) ? Array.new(source) : source
+      def normalize_vector_source(source) = Internal::Vector.normalize_source(source)
 
       def mutate_vector(timeout: nil)
         result = nil

data/lib/farce/atom.rb

@@ -140,6 +140,12 @@ module Farce
       raise LocalJumpError, "no block given" unless block_given?
       check_frozen!
 
+      if timeout.nil?
+        # A hit must still wait for an update in progress.
+        current = @atom.get
+        return unwrap_value(current) unless NIL_VALUE.equal?(current)
+      end
+
       result = @atom.update(timeout:) do |current|
         next current unless NIL_VALUE.equal?(current)
 

data/lib/farce/clock.rb

@@ -115,13 +115,14 @@ module Farce
       raise TypeError, "Cannot convert #{value.class} to clock time"
     end
 
-    alias now        current
-    alias at         time
-    alias timeout_at time
-    alias delay      offset
-    alias in         offset
-    alias timeout    offset
-    alias wait       offset
+    # Copy the bodies eagerly. Lazy module alias resolution can race between Ractors.
+    define_method :now,        instance_method(:current)
+    define_method :at,         instance_method(:time)
+    define_method :timeout_at, instance_method(:time)
+    define_method :delay,      instance_method(:offset)
+    define_method :in,         instance_method(:offset)
+    define_method :timeout,    instance_method(:offset)
+    define_method :wait,       instance_method(:offset)
 
     private
 

data/lib/farce/counter.rb

@@ -13,6 +13,12 @@ module Farce
   #
   # On CRuby, subclasses must not add Ruby instance variables.
   #
+  # @example Allocate sequence numbers across threads or Ractors
+  #   counter = Farce::Counter.new
+  #   ticket = counter.increment # => 1
+  #   counter.increment          # => 2
+  #   ticket                     # => 1
+  #
   # @example Cross-Ractor counting
   #   counter = Farce::Counter.new
   #   counter.value # => 0

data/lib/farce/deduper.rb

@@ -4,9 +4,10 @@
 
 module Farce
   # Reuse equal frozen values throughout object graphs.
-  # Plain strings use Ruby's string deduplication. Arrays, hashes, and Ruby Sets are frozen
-  # and cached by default. Other objects are traversed but are not cached unless
-  # their class matches {#store}. Modules and classes are skipped by default.
+  # Plain strings use Ruby's string deduplication. Arrays, hashes, Ruby Sets, regular
+  # expressions, Data records, and ranges are frozen and cached by default. Other objects are
+  # traversed but are not cached unless their class matches {#store}.
+  # Modules and classes are skipped by default.
   #
   # Cached objects are held weakly. Keep a reference to a returned object if its
   # identity matters. Shareable results can be reused across Ractors. Other
@@ -28,7 +29,7 @@ module Farce
       @shared = Strict::WeakKeyMap.new
       @local  = Local::WeakKeyMap.new
       @skip   = Strict::Vector[Module]
-      @store  = Strict::Vector[Hash, Array, ::Set]
+      @store  = Strict::Vector[Hash, Array, ::Set, Regexp, Data, Range]
       super
     end
 
@@ -68,6 +69,13 @@ module Farce
     # Use copy: true to preserve the input. Skipped objects are always returned
     # unchanged. Strings are deduplicated before skip rules are checked.
     # Noncopyable coordination objects follow {Walker.modify}'s in-place behavior.
+    #
+    # @note
+    #   Deduplication follows Ruby's `hash` and `eql?` semantics. Equal values
+    #   may differ in observable details. For example, `Time` values representing
+    #   the same instant can have different time zones. Deduplicating these values
+    #   or containers holding them may reuse a different timezone representation.
+    #
     # @param object [Object] the root object
     # @param copy [Boolean, Symbol] copying policy passed to {Walker.modify}
     # @param skip [Module, Array<Module>, nil] additional exclusions for this call

data/lib/farce/engine/jvm/counter.rb

@@ -68,7 +68,6 @@ module Farce
           check_frozen!
         end
         @counter.addAndGet(delta).tap { @signal.broadcast }
-        self
       end
 
       def decrement(delta = 1)
@@ -78,7 +77,6 @@ module Farce
           check_frozen!
         end
         @counter.addAndGet(-delta).tap { @signal.broadcast }
-        self
       end
 
       alias value get

data/lib/farce/engine/ruby/shared/weak_cache_mirror.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Internal # :nodoc: all
+    class WeakCacheMirror
+      include Shareable::Delegated
+
+      CACHED_NIL = Object.new.freeze
+      private_constant :CACHED_NIL
+
+      def initialize(shared)
+        @shared = shared
+        super()
+      end
+
+      def store_if_absent(key, &)
+        check_frozen!
+        return @shared.store_if_absent(key, &) unless Ractor.shareable?(key)
+
+        local = local_cache
+        value = local[key]
+        return CACHED_NIL.equal?(value) ? nil : value unless nil.equal?(value)
+
+        value = @shared.store_if_absent(key, &)
+        local[key] = nil.equal?(value) ? CACHED_NIL : value
+        value
+      end
+
+      def fetch(key)
+        return @shared.fetch(key) { yield(key) } unless Ractor.shareable?(key)
+
+        local = local_cache
+        value = local[key]
+        return CACHED_NIL.equal?(value) ? nil : value unless nil.equal?(value)
+
+        value = @shared.fetch(key) { return yield(key) }
+        local[key] = nil.equal?(value) ? CACHED_NIL : value
+        value
+      end
+
+      private
+
+      # CRuby's weak-map operations hold the GVL. Shared misses serialize generation,
+      # and a retained value cannot be replaced, so local hits need no reservation.
+      # Only shareable keys enter the mirror, since mutable strings can change meaning.
+      def local_cache
+        caches = Ractor.store_if_absent(:"Farce::Internal::WeakCacheMirror") { ObjectSpace::WeakKeyMap.new }
+        caches[self] ||= ObjectSpace::WeakMap.new
+      end
+
+      def freeze_backend = @shared
+    end
+  end
+end

data/lib/farce/engine/ruby.rb

@@ -40,10 +40,14 @@ module Farce
       raise e unless e.path == "#{ENGINE_PATH}/patch"
     end
 
-    unless const_defined?(:NATIVE_WEAK_MAPS, false) && NATIVE_WEAK_MAPS
+    if const_defined?(:NATIVE_WEAK_MAPS, false) && NATIVE_WEAK_MAPS
+      def native_weak_maps? = true
+    else
+      def native_weak_maps? = false
       autoload :WeakMap,      "farce/engine/ruby/shared/weak_map"
       autoload :WeakKeyMap,   "farce/engine/ruby/shared/weak_map"
       autoload :WeakValueMap, "farce/engine/ruby/shared/weak_map"
+      autoload :WeakCacheMirror, "farce/engine/ruby/shared/weak_cache_mirror"
     end
 
     StrictAtom    = Atom

data/lib/farce/engine/shared/trie/ignore_case.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Internal
+    class PortableTrie
+      # @api private
+      module IgnoreCase
+        private
+
+        def each_result(input, peek:, deduplicate:, &)
+          raise TypeError, "input must be a String" unless input.is_a?(String)
+          input = String.new(input)
+          validate_encoding!(input, "input")
+
+          input_length = input.length
+          static_input = input.downcase
+          if static_input.length != input_length
+            return each_expanding_result(input, static_input, peek:, deduplicate:, &)
+          end
+          seen = {} if deduplicate
+          stack = [[@root, 0, EMPTY_CAPTURES, EMPTY_NAMED_CAPTURES, 0, 0]]
+
+          until stack.empty?
+            node, position, captures, named, phase, index = stack.pop
+            if phase.zero?
+              child = nil
+              stride = node.stride
+              if node.fast_static
+                key = static_input[position, stride]
+                child = node.fast_static[key] if key
+              elsif position < input_length && !node.static.empty?
+                child = node.static[static_input[position]]
+              end
+              if child
+                # Retain only frames with alternatives or a terminal result.
+                stack << [node, position, captures, named, 1, 0] unless node.dynamic.empty? && node.tokens.empty?
+                stack << [child, position + stride, captures, named, 0, 0]
+                next
+              end
+            end
+            if index < node.dynamic.length
+              regexp, child = node.dynamic[index]
+              if index + 1 < node.dynamic.length || !node.tokens.empty?
+                stack << [node, position, captures, named, 1, index + 1]
+              end
+              if (matched = regexp.match(input, position))
+                stack << [
+                  child,
+                  matched.end(0),
+                  captures + matched.captures,
+                  merge_named_captures(named, matched.named_captures),
+                  0,
+                  0
+                ]
+              end
+            elsif (peek || position == input_length) && !node.tokens.empty?
+              node.tokens.each do |token_id|
+                next if deduplicate && seen.key?(token_id)
+
+                seen[token_id] = true if deduplicate
+                yield(
+                  @tokens.fetch(token_id),
+                  captures.map { |value| value&.dup },
+                  copy_named_captures(named),
+                  input[position..] || +""
+                )
+              end
+            end
+          end
+        end
+
+        def each_expanding_result(input, static_input, peek:, deduplicate:)
+          to_original = [0]
+          from_original = [0]
+          input.each_char.with_index do |character, index|
+            count = character.downcase.length
+            # An internal lowercase boundary cannot start a regexp or end a result.
+            (count - 1).times { to_original << nil }
+            to_original << (index + 1)
+            from_original << (to_original.length - 1)
+          end
+          input_length = static_input.length
+          seen = {} if deduplicate
+          stack = [[@root, 0, EMPTY_CAPTURES, EMPTY_NAMED_CAPTURES, 0, 0]]
+
+          until stack.empty?
+            node, position, captures, named, phase, index = stack.pop
+            original_position = to_original[position]
+            case phase
+            when 0
+              stack << [node, position, captures, named, 1, 0]
+              if node.fast_static
+                key = static_input[position, node.stride]
+                if key && (child = node.fast_static[key])
+                  stack << [child, position + node.stride, captures, named, 0, 0]
+                end
+              elsif position < input_length && (child = node.static[static_input[position]])
+                stack << [child, position + 1, captures, named, 0, 0]
+              end
+            when 1
+              if index < node.dynamic.length
+                regexp, child = node.dynamic[index]
+                stack << [node, position, captures, named, 1, index + 1]
+                if original_position && (matched = regexp.match(input, original_position))
+                  stack << [
+                    child,
+                    from_original[matched.end(0)],
+                    captures + matched.captures,
+                    merge_named_captures(named, matched.named_captures),
+                    0,
+                    0
+                  ]
+                end
+              elsif original_position && (peek || position == input_length) && !node.tokens.empty?
+                node.tokens.each do |token_id|
+                  next if deduplicate && seen.key?(token_id)
+
+                  seen[token_id] = true if deduplicate
+                  yield(
+                    @tokens.fetch(token_id),
+                    captures.map { |value| value&.dup },
+                    copy_named_captures(named),
+                    input[original_position..] || +""
+                  )
+                end
+              end
+            end
+          end
+        end
+      end
+      private_constant :IgnoreCase
+    end
+  end
+end

data/lib/farce/engine/shared/trie.rb

@@ -76,11 +76,16 @@ module Farce
       end
       private_constant :Node
 
-      def initialize(entries, tokens)
+      def initialize(entries, tokens, ignore_case: false)
         validate_array!(entries, "entries")
         validate_array!(tokens, "tokens")
         validate_tokens!(tokens)
 
+        if ignore_case
+          @ignore_case = true
+          extend IgnoreCase
+        end
+
         @tokens      = Array.new(tokens).freeze
         @root        = Node.new
         nodes        = [@root]
@@ -103,6 +108,7 @@ module Farce
             when String
               literal = String.new(part)
               validate_encoding!(literal, "edge")
+              literal.downcase! if ignore_case
               literal.each_char do |character|
                 child = node.static[character]
                 unless child
@@ -171,6 +177,12 @@ module Farce
 
       private
 
+      def initialize_dup(other)
+        super
+        # Unlike clone, dup does not retain the instance's matching module.
+        extend IgnoreCase if @ignore_case
+      end
+
       def anchor(regexp)
         compile_regexp("\\G(?:#{regexp.source})", regexp)
       rescue RegexpError
@@ -314,4 +326,5 @@ module Farce
   end
 end
 
+require "farce/engine/shared/trie/ignore_case"
 require "farce/engine/shared/trie_builder"

data/lib/farce/engine/shared/trie_builder.rb

@@ -17,6 +17,13 @@ module Farce
     # terminal match. A regexp edge is atomic. Later edges cannot make a regexp
     # choose a different endpoint.
     #
+    # Pass `ignore_case: true` to {.build} or {Builder.new} to compare all static
+    # segments using Unicode downcasing. Regexp options do not change. Regexp
+    # matches, captures, and suffixes use the original input and retain its casing.
+    # This does not include every equivalence supported by `Regexp::IGNORECASE`.
+    # For example, `"SS"` matches `"ss"`, but `"ß"` does not match `"ss"`.
+    # Case-equivalent static entries share a branch and retain their token order.
+    #
     # Tokens must already be Ractor-shareable. They are stored and returned
     # unchanged. Equal but different token objects remain separate. Reusing the
     # same token object produces at most one result per lookup.
@@ -94,20 +101,23 @@ module Farce
       # Collects entries and publishes immutable {Trie} snapshots.
       class Builder
         # Create an empty builder.
-        def initialize
+        # @param ignore_case [Boolean] compare all static segments without case
+        def initialize(ignore_case: false)
           @entries = []
+          @ignore_case = !!ignore_case
         end
 
         # @api private
         def marshal_dump
           entries = @entries.map { |parts, token| [parts, Internal::MarshalSupport.value(token)] }
-          [1, entries, frozen?]
+          [1, entries, frozen?, @ignore_case]
         end
 
         # @api private
         def marshal_load(data)
-          entries, frozen = Internal::MarshalSupport.payload(data, 2)
-          initialize
+          length = data.is_a?(Array) && data.length == 3 ? 2 : 3
+          entries, frozen, ignore_case = Internal::MarshalSupport.payload(data, length)
+          initialize(ignore_case:)
           entries.each { |parts, token| add(parts, Internal::MarshalSupport.restore_value(token)) }
           freeze if frozen
         end
@@ -159,7 +169,7 @@ module Farce
             [parts.dup.freeze, token_ids.fetch(token)].freeze
           end.freeze
 
-          Trie.send(:build_entries, entries, tokens.freeze)
+          Trie.send(:build_entries, entries, tokens.freeze, ignore_case: @ignore_case)
         end
 
         private
@@ -180,17 +190,18 @@ module Farce
       class << self
         # Build an immutable trie.
         #
+        # @param ignore_case [Boolean] compare all static segments without case
         # @yieldparam builder [Builder]
         # @return [Trie]
-        def build
-          builder = Builder.new
+        def build(ignore_case: false)
+          builder = Builder.new(ignore_case:)
           yield builder if block_given?
           builder.build
         end
 
         private
 
-        def build_entries(entries, tokens) = new(entries, tokens)
+        def build_entries(entries, tokens, ignore_case:) = new(entries, tokens, ignore_case:)
 
         private :new
       end

data/lib/farce/engine/shared/unshared_vector.rb

@@ -6,9 +6,11 @@ module Farce
   # @!visibility private
   module Internal # :nodoc: all
     class UnsharedVector
+      def self.normalize_source(source) = source.is_a?(Integer) ? Array.new(source) : source
+
       def initialize(source = nil, compare_by_identity: false)
         validate_boolean(compare_by_identity, "compare_by_identity")
-        raise TypeError, "source must be an Array" unless source.nil? || source.is_a?(Array)
+        raise TypeError, "source must be an Array" unless source.nil? || source.is_a?(Array) || source.is_a?(Integer)
 
         @values              = source ? Array.new(source) : []
         @compare_by_identity = compare_by_identity

data/lib/farce/engine/shared/vector.rb

@@ -6,6 +6,8 @@ module Farce
   # @!visibility private
   module Internal # :nodoc: all
     class Vector < UnsharedVector
+      def self.new_for_modes(source) = new(source, compare_by_identity: true)
+
       def initialize(source = nil, **)
         source.each { check_value(it) } if source.is_a?(Array)
         super

data/lib/farce/engine/shared.rb

@@ -54,6 +54,8 @@ module Farce
       end
     end
 
+    def native_weak_maps? = true
+
     # define_method supplies the receiver. Rebinding first is unnecessary without
     # native Ractor isolation and can change the method context used by super.
     def prepare_method_definition(&definition) = definition

data/lib/farce/engine/truffleruby/native/counter.rb

@@ -60,7 +60,6 @@ module Farce
           check_frozen!
         end
         change(delta)
-        self
       end
 
       def decrement(delta = 1)
@@ -70,7 +69,6 @@ module Farce
           check_frozen!
         end
         change(-delta)
-        self
       end
 
       alias value get

data/lib/farce/engine/truffleruby.rb

@@ -39,6 +39,15 @@ module Farce
 
     def native_ractors? = false
 
+    # Range#initialize rejects open endpoints on TruffleRuby, while Range.new accepts them.
+    def initialize_range(target, first, last, exclude_end)
+      if first.nil? || last.nil?
+        target.__send__(:initialize_copy, target.class.new(first, last, exclude_end))
+      else
+        target.__send__(:initialize, first, last, exclude_end)
+      end
+    end
+
     # @api private
     # TruffleRuby probes this additional hook before using _dump.
     def marshal_protocol_method?(name)