farce 0.0.1.alpha2-x86_64-linux-gnu

data/SECURITY.md

@@ -0,0 +1,10 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please do not open public issues or pull requests about open security vulnerabilities.
+
+Report vulnerabilities privately to [security@rkh.im](mailto:security@rkh.im) with the subject line "Farce Security Vulnerability Report".
+Include a description of the vulnerability, affected versions, and steps to reproduce it.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for general contribution guidelines.

data/docs/benchmarks.md

@@ -0,0 +1,185 @@
+<!--
+# @title Benchmarks
+-->
+
+# Benchmarks
+
+Farce also aims to be fast and efficient, aiming for anywhere between a minimal overhead to outperforming other options.
+
+Any numbers quoted here are to be taken with a grain of salt:
+
+* They are based on micro-benchmarks, which may not reflect real-world performance.
+* They are momentary snapshots. Gems and Ruby implementations are constantly evolving,
+  so these numbers may not be accurate in the future.
+* Concrete numbers are largely measured on a local machine, which may not reflect your deployment environment.
+
+You should measure the performance of your own application under realistic conditions.
+
+## Map performance
+
+A shared map is a very common data structure for tracking state. While the read and write performance is hopefully not the bottleneck for your application.
+
+ Map implementation          | Read        | Write       | Notes
+-----------------------------|-------------|-------------|-----
+ `Hash`                      | fastest     | fastest     | Not ractor-shareable (when mutable), not thread-safe
+ `Concurrent::Hash`          | 1.1x slower | 1.1x slower | Not ractor-shareable
+ `Farce::Strict::Map`        | 1.2x slower | 1.1x slower |
+ `Farce::Unshared::Map`      | 1.2x slower | 1.1x slower | Not ractor-shareable
+ `Farce::Map`                | 1.3x slower | 1.1x slower |
+ `Concurrent::Map`           | 1.4x slower | 3.2x slower | Not ractor-shareable
+ `Hash` + `Mutex`            | 2.9x slower | 2.9x slower | Not ractor-shareable
+ `Ractor::LockHash`          | 2.9x slower | 3.4x slower | Not fiber-friendly
+ `Ratomic::Map`              | 3.1x slower | 2.7x slower | Breaks isolation, not fiber-friendly
+ `Ractor::KeyLockHash`       | 3.2x slower | 2.5x slower | Not fiber-friendly
+ `Farce::LRUMap`             | 3.4x slower | 7.6x slower | Automatic eviction
+ `Farce::LFUMap`             | 3.5x slower | 7.6x slower | Automatic eviction
+ `Farce::Unsafe::TreeMap`    | 3.7x slower | 4.1x slower | Ordered entries, not thread-safe, not ractor-shareable
+ `HashWithIndifferentAccess` | 4.5x slower | 5.3x slower | Not ractor-shareable
+ `RactorSafe::HashMap`       | 4.8x slower | 4.8x slower | 
+ `Farce::TreeMap`            | 5.5x slower | 40x slower  | Ordered entries
+ `Farce::LeaseMap`           | 30x slower  | 40x slower  | Shared ractor for all lease maps
+ `Ractor::ActorHash`         | 400x slower | 280x slower | Additional ractor per map
+
+The map implementations namespaced under `Ractor` are from the [ractor-sharing](https://github.com/ko1/ractor-sharing) gem.
+
+Also note that `Ratomic::Map` has a significant performance benefit over all other implementations when repeatedly writing to different keys in very large maps concurrently on a very high number of Ractors due to the underlying [DashMap](https://github.com/xacrimon/dashmap) implementing data sharding. This benefit does not materializes if different Ractors share the keys they use, so its usefulness is slightly hampered by the fact that you cannot iterate over Ratomic's maps at all.
+
+## Counter performance
+
+> [!CAUTION] 
+> If counter performance is your application's bottleneck, **Ruby might not be the right choice for you**.
+
+### CRuby (4.0)
+
+ Implementation      | Increment   | Read value     | Integer size | Note
+---------------------|-------------|----------------|--------------|-------
+ farce               | fastest     | fastest        | 64-bit       |
+ concurrent-ruby-ext | 1.2x slower | same-ish       | 32-bit       | no ractor support
+ ratomic             | 1.5x slower | 1.6x slower    | 64-bit       | no overflow protection
+ ractor_safe         | 2.1x slower | 2.1x slower    | 64-bit       |
+ concurrent-ruby     | 12x slower  | 5x slower      | 32-bit       | no ractor support
+
+Performance differences between implementations are consistent between single-threaded and multi-threaded benchmarks.
+
+### JRuby
+
+ Implementation      | Increment   | Read value     | Integer size
+---------------------|-------------|----------------|--------------
+ concurrent-ruby-ext | fastest     | fastest        | 64-bit
+ farce               | 1.7x slower | 2.2x slower    | 64-bit
+ concurrent-ruby     | 15x slower  | 9x slower      | 32-bit
+
+Farce uses a JVM-specific Ruby implementation, concurrent-ruby uses the same Mutex-based implementation as on other platforms, and concurrent-ruby-ext comes with a Java implementation of an atomic counter (hence also the difference in integer size). The overhead in Farce can largely be attributed to Ruby dispatch overhead.
+
+### TruffleRuby
+
+ Implementation      | Increment   | Read value     | Integer size
+---------------------|-------------|----------------|--------------
+  farce              | fastest     | fastest        | 64-bit
+  concurrent-ruby    | 1.5x slower | 3.5x slower    | 32-bit
+
+TruffleRuby's performance numbers are not as reliable as other Ruby implementations, and may vary significantly between runs, versions, and whether the GraalVM is in use and has warmed up. Neither farce nor concurrent-ruby use a counter written in C, so they should both be fully optimizable by the GraalVM.
+
+## Lock performance
+
+> [!CAUTION] 
+> If lock performance is your application's bottleneck, you might want to look into **different data structures**.
+> Farce and concurrent-ruby provide plenty of options.
+
+### CRuby
+
+Farce's locks are **between 5% and 10% slower** than `Mutex` for uncontended locks, and stay below a 50% performance penalty for highly contended locks between threads.
+
+### JRuby and TruffleRuby
+
+Farce's locks have identical performance to `Mutex` (as they are a subclass of `Mutex`).
+
+## Queue performance
+
+In the producer/consumer workload in `benchmark/queue.rb`, Ruby's built-in `Thread::Queue` and `Thread::SizedQueue` remain the fastest, but they do not support ractors.
+
+ Implementation                | Performance | Notes
+-------------------------------|-------------|-------------
+ `Thread::Queue`               | Fastest     | no ractor support
+ `Thread::SizedQueue`          | 1.4x slower | no ractor support
+ `Farce::Strict::Queue`        | 1.5x slower | only allows sharable objects
+ `Farce::Queue`                | 2.1x slower |
+ `RactorSafe::Queue`           | 2.9x slower | only allows sharable objects
+ `Ratomic::Queue`              | 9.8x slower | breaks ractor isolation
+ `RactorQueue`                 | 30x slower  | breaks ractor isolation
+ `Ractor::Port` (multiplexing) | 100x slower |
+
+## Priority queue performance
+
+Many gems implement a priority queue or comparable data structure.
+Farce's implementation is the only one that allows cross-ractor communication.
+The below numbers compare non-blocking APIs, as only Farce implements a blocking API as well.
+
+<table>
+  <thead>
+    <tr>
+      <th colspan="2"></th>
+      <th colspan="2">CRuby</th>
+      <th colspan="2">JRuby</th>
+    </tr>
+    <tr>
+      <th>↓ Gem</th>
+      <th>Insertion order →</th>
+      <th>Random</th>
+      <th>Descending</th>
+      <th>Random</th>
+      <th>Descending</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td colspan="2">farce 0.1.0</td>
+      <td>fastest</td>
+      <td>fastest</td>
+      <td>fastest</td>
+      <td>fastest</td>
+    </tr>
+    <tr>
+      <td colspan="2"><a href="https://github.com/mame/rbtree">rbtree</a> 0.4.7</td>
+      <td>1.1x slower</td>
+      <td>1.2x  slower</td>
+      <td>–</td>
+      <td>–</td>
+    </tr>
+    <tr>
+      <td colspan="2"><a href="https://github.com/boborbt/priority_queue_cxx">priority_queue_cxx</a> 0.3.7</td>
+      <td>1.7x slower</td>
+      <td>1.7x slower</td>
+      <td>–</td>
+      <td>–</td>
+    </tr>
+    <tr>
+      <td colspan="2"><a href="https://github.com/socketry/io-event">io-event</a> 1.21.1</td>
+      <td>2.6x slower</td>
+      <td>3.9x slower</td>
+      <td>1.3x slower</td>
+      <td>1.7x slower</td>
+    </tr>
+    <tr>
+      <td colspan="2"><a href="https://github.com/rubyworks/pqueue">pqueue</a> 2.2.0</td>
+      <td>9.5x slower</td>
+      <td>8.0x slower</td>
+      <td>2.2x slower</td>
+      <td>1.9x slower</td>
+    </tr>
+    <tr>
+      <td colspan="2"><a href="https://github.com/matiasbattocchia/lazy-priority-queue">lazy_priority_queue</a> 0.1.1</td>
+      <td>9.9x slower</td>
+      <td>7.9x slower</td>
+      <td>3.9x slower</td>
+      <td>3.2x slower</td>
+    </tr>
+    <tr>
+      <td colspan="2"><a href="https://github.com/philiprehberger/rb-priority-queue">philiprehberger-priority_queue</a> 0.5.0</td>
+      <td>13x slower</td>
+      <td>19x slower</td>
+      <td>7.6x slower</td>
+      <td>11x slower</td>
+    </tr>
+  </tbody>
+</table>

data/docs/gems/dry-types.md

@@ -0,0 +1,290 @@
+<!--
+# @title Gem: dry-types
+-->
+
+# Farce / [dry-types](https://dry-rb.org/gems/dry-types/)
+
+The opt-in dry-types integration validates input and constructs Farce values
+from the result. It is useful when parsed input is headed to concurrent workers
+or Farce-backed application state.
+
+Add `dry-types` to your application and include both type imports:
+
+```ruby
+require "dry-types"
+require "farce"
+
+module Types
+  include Dry.Types()
+  include Farce.DryTypes()
+end
+```
+
+`Farce.DryTypes()` follows the preceding `Dry.Types()` import. Root Farce types
+use the corresponding dry default types. Namespaces and aliases gain matching
+Farce constants without replacing existing dry types. Loading Farce by itself
+does not load dry-types.
+
+The imported constants construct new Farce objects. Use an instance type to
+check an existing Farce object without conversion:
+
+```ruby
+module Types
+  VectorInstance = Instance(Farce::Vector)
+end
+
+Types::VectorInstance.try(Farce::Vector.new).success? # => true
+Types::VectorInstance.try([]).failure?                # => true
+```
+
+## Vectors
+
+Use `Vector.of` to apply a member type before constructing the vector:
+
+```ruby
+module Types
+  IntegerVector = Vector.of(Coercible::Integer)
+end
+
+numbers = Types::IntegerVector[["1", 2]]
+numbers.class # => Farce::Vector
+numbers.to_a  # => [1, 2]
+numbers.mode  # => :copy
+```
+
+The bare `Vector` accepts any Array members. Imported dry namespaces control
+the outer native input in the same way as their Array type:
+
+```ruby
+Types::Vector.try("one").failure?    # => true
+Types::Coercible::Vector["one"].to_a # => ["one"]
+```
+
+The resulting values compose with optional types, constraints, `try`, and
+failure blocks:
+
+```ruby
+Types::IntegerVector.optional[nil] # => nil
+
+result = Types::IntegerVector.try(["invalid"])
+result.failure? # => true
+
+Types::IntegerVector.(["invalid"]) { |partial| [:invalid, partial] }
+# => [:invalid, ["invalid"]]
+```
+
+Member and source coercion complete before Farce construction. Their failure
+blocks receive dry-types' partial native value, never a partially initialized
+Farce collection. Constraints added to a collection type run on its constructed
+Farce result. A size constraint on a Set therefore observes deduplication.
+
+dry-types callable defaults return the block result directly. Construct the
+typed value inside the block when each use needs a fresh Farce collection:
+
+```ruby
+module Types
+  EmptyIntegerVector = IntegerVector.default { IntegerVector[[]] }
+end
+
+Types::EmptyIntegerVector[].class  # => Farce::Vector
+Types::EmptyIntegerVector[].empty? # => true
+```
+
+## Maps and schemas
+
+Use `Map.map` for homogeneous key and value types:
+
+```ruby
+module Types
+  ScoreMap = Map.map(String, Coercible::Integer)
+end
+
+scores = Types::ScoreMap["Ada" => "10", "Grace" => 12]
+scores.class # => Farce::Map
+scores.to_h  # => {"Ada" => 10, "Grace" => 12}
+```
+
+dry-types rejects keys that collide after coercion. The integration also
+rejects identity Hash input with structurally equal keys because a structural
+Farce Map could otherwise drop an entry.
+
+Use `Map.schema` for fixed keys, defaults, key transforms, and nested types:
+
+```ruby
+module Types
+  Batch = Map.schema(
+    name: String,
+    ids: IntegerVector,
+  ).strict
+end
+
+batch = Types::Batch[name: "nightly", ids: ["10", 20]]
+batch[:name]      # => "nightly"
+batch[:ids].class # => Farce::Vector
+batch[:ids].to_a  # => [10, 20]
+```
+
+Schema chaining and `with_key_transform` or `with_type_transform` retain Farce
+construction. A non-strict schema omits unknown keys. Call `.strict` when
+unknown keys should fail.
+
+## Sets
+
+`Set.of` applies its member type before membership removes duplicates:
+
+```ruby
+module Types
+  IntegerSet = Set.of(Coercible::Integer)
+end
+
+values = Types::IntegerSet[["1", 1, "2"]]
+values.class     # => Farce::Set
+values.to_a.sort # => [1, 2]
+```
+
+It accepts Arrays and Ruby Sets. The bare `Set` accepts any Array members.
+
+## Counters and flags
+
+`Counter` uses the imported dry `Integer` type. `Flag` uses the imported dry
+`Bool` type:
+
+```ruby
+counter = Types::Coercible::Counter["3"]
+counter.class # => Farce::Counter
+counter.value # => 3
+
+flag = Types::Params::Flag["yes"]
+flag.class # => Farce::Flag
+flag.value # => true
+```
+
+A namespace only gains a Farce type when it has the corresponding dry type.
+For example, dry-types defines `Coercible::Integer` but no `Coercible::Bool`,
+so `Types::Coercible::Counter` exists while `Types::Coercible::Flag` does not.
+
+The dry type validates the initial scalar. Counter and Flag retain their normal
+Farce APIs after construction.
+
+## Atoms
+
+The bare `Atom` accepts any initial value. Use `Atom.of` to validate or coerce
+the initial contents:
+
+```ruby
+module Types
+  IntegerAtom = Atom.of(Coercible::Integer)
+end
+
+atom = Types::IntegerAtom["4"]
+atom.class # => Farce::Atom
+atom.value # => 4
+```
+
+The type applies only at construction. Later writes use the normal Atom API and
+are not revalidated:
+
+```ruby
+atom.value = "later"
+atom.value # => "later"
+```
+
+Nil as Atom contents differs from an optional Atom constructor:
+
+```ruby
+Types::Atom[nil].value                             # => nil
+Types::Atom.of(Types::Integer.optional)[nil].value # => nil
+Types::Atom.of(Types::Integer).optional[nil]       # => nil
+```
+
+The first two expressions construct an Atom containing nil. The last expression
+returns nil without constructing an Atom.
+
+## Dry imports and Farce variants
+
+With no dry namespace arguments, `Farce.DryTypes()` inherits the closest
+`Dry.Types()` import. With no preceding import, it uses the same strict defaults
+as `Dry.Types()`. Pass dry namespace arguments, `default:`, and aliases to
+select an independent source using the normal `Dry.Types()` rules:
+
+```ruby
+module CoercingTypes
+  include Dry.Types()
+  include Farce.DryTypes(:strict, :coercible, default: :coercible)
+end
+
+CoercingTypes::Vector["1"].to_a # => ["1"]
+```
+
+The dry namespace controls validation and coercion of native input. `variant:`
+selects the Farce class produced after that succeeds:
+
+```ruby
+module LocalTypes
+  include Dry.Types(default: :coercible)
+  include Farce.DryTypes(variant: :local, scope: :fiber)
+end
+
+vector = LocalTypes::Vector["job"]
+vector.class # => Farce::Local::Vector
+vector.scope # => :fiber
+```
+
+Supported variants are `:shared`, `:strict`, `:unshared`, and `:local`.
+`:shared` is the default and accepts `mode:`. `:local` accepts `scope:`.
+Strict and Unshared variants accept neither option. Farce's `:strict` variant
+and dry-types' `Strict` namespace configure separate parts of the conversion.
+
+| `variant:` | Constructed classes |
+| --- | --- |
+| `:shared` | `Farce::Vector`, `Farce::Map`, `Farce::Set`, `Farce::Counter`, `Farce::Flag`, `Farce::Atom` |
+| `:strict` | `Farce::Strict::Vector`, `Farce::Strict::Map`, `Farce::Strict::Set`, `Farce::Strict::Atom` |
+| `:unshared` | `Farce::Unshared::Vector`, `Farce::Unshared::Map`, `Farce::Unshared::Set` |
+| `:local` | `Farce::Local::Vector`, `Farce::Local::Map`, `Farce::Local::Set`, `Farce::Local::Counter`, `Farce::Local::Flag`, `Farce::Local::Atom` |
+
+The integration imports only classes that Farce provides for the selected
+variant. Strict has an Atom but no Counter or Flag. Unshared has none of these
+three scalar-backed types.
+
+For a single shared collection type, use `.with(mode: ...)`:
+
+```ruby
+module Types
+  LocalValueVector = Vector.with(mode: :local)
+end
+
+payload = []
+vector = Types::LocalValueVector[[payload]]
+vector[0].equal?(payload) # => true
+```
+
+The supported shared modes are `:copy`, `:local`, `:make_shareable`,
+`:shareable_copy`, and `:raise`. They apply to collections and Atom. Counter and
+Flag have no transfer mode. `:move` is rejected because dry-types creates and
+examines intermediate values during coercion.
+
+## Farce input and ownership
+
+Mode-free Strict, Unshared, and Local Farce collections can be converted
+directly. Construction always returns a fresh configured variant.
+
+Mode-backed `Farce::Vector`, `Farce::Map`, and `Farce::Set` input is rejected
+before traversal. Materialize one explicitly when reading it is intended:
+
+```ruby
+source = Farce::Vector.new(["1"])
+converted = Types::IntegerVector[source.to_a]
+converted.to_a # => [1]
+```
+
+The explicit read establishes where transfer and ownership happen. This rule
+also applies when the container's default mode is `:copy` because an individual
+entry might have been inserted with `mode: :move`.
+
+Vector materialization uses its normal snapshot. Map and set materialization
+uses normal iteration and is not a globally atomic snapshot during concurrent
+mutation. Validation describes the values processed by that call. Later writes
+through the Farce API are not revalidated. Atom input is treated as its payload
+and is never implicitly read from an existing Atom. Mutable values keep the
+guarantees of the selected Farce mode. The dry type descriptor is application
+configuration and is not promised to be Ractor-shareable.

data/docs/gems/msgpack.md

@@ -0,0 +1,70 @@
+<!--
+# @title Gem: MessagePack
+-->
+
+# Farce / [MessagePack](https://github.com/msgpack/msgpack-ruby)
+
+Use MessagePack to store or send Farce values. Add `msgpack` to your Gemfile
+and load it:
+
+```ruby
+require "msgpack"
+require "farce"
+
+jobs  = Farce::Vector.new(["build", "test"])
+bytes = jobs.to_msgpack # or: MessagePack.pack(jobs)
+```
+
+Vectors, maps, sets, atoms, counters, and flags support `to_msgpack`, including
+nested values and their Farce variants.
+
+## Restoring Farce objects
+
+By default, unpacking returns ordinary Ruby values: arrays for vectors and sets,
+hashes for maps, integers for counters, booleans for flags, and the stored values
+for atoms. This makes the data easy to use outside Farce:
+
+```ruby
+MessagePack.unpack(bytes) # => ["build", "test"]
+```
+
+To restore Farce objects instead, use a factory for both packing and unpacking:
+
+```ruby
+factory = Farce::MessagePack.factory
+copy = factory.load(factory.dump(jobs))
+copy.class # => Farce::Vector
+copy.to_a  # => ["build", "test"]
+```
+
+The factory also restores nested Farce objects. It does not change
+`MessagePack.pack` or `to_msgpack`. Restored objects contain the current values,
+and counters retain their initial value for `reset`. Other settings, such as
+transfer modes and local scopes, use constructor defaults unless configured below.
+
+## Custom factories
+
+Choose extension IDs to fit your application's protocol:
+
+```ruby
+factory = Farce::MessagePack.factory(types: {
+  Farce::Vector  => 40,
+  Farce::Counter => 41
+})
+```
+
+`types:` replaces the default registrations, which use IDs 0 through 5 for
+Vector, Map, Counter, Flag, Atom, and Set, respectively. Both ends must use the
+same registrations. Register variants explicitly to restore their specific classes.
+
+You can also add Farce types to an existing MessagePack factory and supply
+constructor options for restored objects:
+
+```ruby
+factory = MessagePack::Factory.new
+Farce::MessagePack.register_type(factory, 60, Farce::Vector, mode: :make_shareable)
+Farce::MessagePack.register_type(factory, 61, Farce::Local::Counter, scope: :fiber)
+```
+
+Use unused IDs from 0 through 127. Nested values use the same factory, including
+your application's other registered types.

data/docs/gems/ractor-shim.md

@@ -0,0 +1,63 @@
+<!--
+# @title Gem: ractor-shim
+-->
+
+# Farce / [ractor-shim](https://github.com/eregon/ractor-shim)
+
+> [!NOTE]
+> This documentation is up to date for **Farce 0.1.0** and **ractor-shim 0.1.1**.
+
+Both Farce and [ractor-shim](https://github.com/eregon/ractor-shim) provide shims for `Ractor` and `Ractor::Port` on platforms that don't fully support them. Farce namespaces these inside the `Farce` module, while ractor-shim installs these classes at top-level (where any shim-unaware code would automatically pick them up).
+
+Farce ignores the shims provided by ractor-shim. Both gems can safely coexist in the same application.
+
+## Similarities
+
+* Both of them will use `Thread` and `Queue` under the hood if Ractors are not available.
+* Both implement most of the public Ractor API.
+* On Ruby implementations not supporting Ractors they both treat all objects as shareable. `Ractor.make_shareable` will not deep-freeze objects, and `Ractor.shareable?` will always return true.
+
+## Implementation differences
+
+The Ruby requirements for ractor-shim are much broader than for Farce, supporting Ruby 2.7 and later, while Farce requires Ruby 3.4 or newer. Farce is also significantly larger and more complex than ractor-shim. Its primary purpose isn't to provide a shim, but to provide tooling around Ractors and Fiber schedulers. So if all you need is a simple shim, ractor-shim is likely a better choice.
+
+However, having these tools at its disposal allows Farce to provide a more complete and in some cases more performant solution.
+
+### Things Farce implements that ractor-shim does not
+
+Farce supports ractors having multiple threads. The following snippet will work fine with Farce (after `include Farce`), but will raise an exception with ractor-shim on Ruby 2.x, TruffleRuby, and JRuby:
+
+```ruby
+Ractor.new do
+  Thread.new { p Ractor.current }.join
+end.join
+```
+
+The `Ractor.store_if_absent` method provided by ractor-shim may not be thread-safe.
+
+`Ractor.shareable_proc` and `Ractor.shareable_lambda` are not properly implemented in ractor-shim. They do not accept a `self` option and will not rebind the passed block. In addition, `shareable_lambda` does not actually produce lambdas on Ruby 3.
+
+### Things Farce implements more efficiently
+
+* `Ractor.select` on ractor-shim uses busy waiting if native Ractors are not available. Farce uses better synchronization mechanisms to properly avoid busy waiting. Moreover, ractor-shim wraps the select logic in a global mutex, meaning only one `Ractor.select` can be active at any time. Farce does not have this limitation.
+* The `Ractor::Port` shim provided by ractor-shim always creates a new Ractor for each port. Farce only does so if absolutely necessary (on Ruby 3.4, if sending unshareable objects over a non-default port).
+
+On Ruby 3.4, the following code will create one Ractor if using Farce, but 6 Ractors if using ractor-shim:
+
+```ruby
+ractor = Ractor.new do
+  counter = 0
+  while port = receive
+    counter += 1
+    port.send(counter)
+  end
+end
+
+5.times do
+  port = Ractor::Port.new
+  ractor.send(port)
+  puts "Count is: #{port.receive}"
+ensure
+  port.close
+end
+```