ractor-tmvar 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61f2c5af774133ccaca92fd2ab9d5926d1faf7d229d60f62c7928e82c8e06cef
-  data.tar.gz: d5e176ee4886ca2f5feea7f20c9b3989e33778b3a433e7f550e281b43c9bfb72
+  metadata.gz: 6f3245eebf48796294d345ac5d97677c3f536347f87a204555223781cec1a87d
+  data.tar.gz: 3bf7ca844e8556db49d981b2d50c6e00867927f70348d59242220b66d0e20a59
 SHA512:
-  metadata.gz: 605a25ac148a512f7d2a8c18d98e6c73cae522fb69963e7a9b5357b4165efeb044a8b0e425a2172f2ad81278a1a632a434bfeb4d22a8047e4cd44e99630a49c9
-  data.tar.gz: 9523eb78bbef48de3b809df3a442eaa2be9df55573e2ea1e0d4a7b3692977a062ba36ca6de18182800dea1c46b0120aa50e28316d21136816af09fc4d65e5522
+  metadata.gz: b30e17fdb2e91c2aa60e83edf47098926a017a63a192a409545116ef7ec605ab2203361f00862de5e8f2e443058dc3c7111b69a77bf4373d9f718e74faff5c1c
+  data.tar.gz: 567905c4e3ae0b351a0ecaaa69b97a5de09d77e7047da0e07cee7e45818251097e2e12bf32e3ebf173bfff48ccf3dada4ba40c29ad153a87da2176028f098058

data/.github/workflows/build-gem.yml

@@ -0,0 +1,54 @@
+name: Build and attest gem
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+      attestations: write
+    steps:
+      - name: Check out tagged source
+        uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6
+        with:
+          ref: ${{ github.sha }}
+          persist-credentials: false
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@e81a8fa391b11a595c1b7ed84177cc0fe02faf83 # v1
+        with:
+          ruby-version: '4.0'
+          bundler-cache: true
+
+      - name: Check release tag matches gem version
+        run: |
+          ruby -r ./lib/ractor/tmvar/version -e '
+            expected = "refs/tags/v#{Ractor::TMVar::VERSION}"
+            abort "Expected #{expected}, got #{ENV.fetch("GITHUB_REF")}" unless ENV.fetch("GITHUB_REF") == expected
+          '
+
+      - name: Run tests and lint
+        run: bundle exec rake
+
+      - name: Build gem
+        run: |
+          mkdir -p pkg
+          gem build ractor-tmvar.gemspec --output "pkg/ractor-tmvar-${GITHUB_REF_NAME#v}.gem"
+
+      - name: Attest gem provenance
+        uses: actions/attest@1e69f48acb82d1966a394da916b4c1698aa569d6 # v4
+        with:
+          subject-path: pkg/*.gem
+
+      - name: Save gem
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        with:
+          name: ractor-tmvar-${{ github.ref_name }}
+          path: pkg/*.gem
+          if-no-files-found: error

data/.github/workflows/main.yml

@@ -6,7 +6,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu]
-        ruby: [head, debug]
+        ruby: [head, debug, '4.0']
 
     runs-on: ${{ matrix.os }}-latest
     continue-on-error: ${{ matrix.ruby == 'head' || matrix.ruby == 'debug' }}

data/.github/workflows/release.yml

@@ -0,0 +1,17 @@
+name: Build release gem
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    permissions:
+      contents: read
+      id-token: write
+      attestations: write
+    uses: ./.github/workflows/build-gem.yml

data/.gitignore

@@ -6,3 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+/vendor/
+.pi
+.env
+.env.local

data/.rubocop.yml

@@ -1,5 +1,7 @@
+plugins:
+  - rubocop-rake
+
 AllCops:
-  TargetRubyVersion: 2.7
   NewCops: enable
 
 Style/StringLiterals:
@@ -17,3 +19,7 @@ Metrics/ClassLength:
   Enabled: true
   Exclude:
     - "test/**/*"
+
+Naming/PredicateMethod:
+  AllowedMethods:
+    - try_put

data/Gemfile

@@ -9,4 +9,6 @@ gem "rake", "~> 13.0"
 
 gem "test-unit", "~> 3.0"
 
-gem "rubocop", "~> 0.80"
+gem "rubocop", "~> 1.91"
+
+gem "rubocop-rake", "~> 0.7"

data/Gemfile.lock

@@ -1,46 +1,85 @@
 PATH
   remote: .
   specs:
-    ractor-tmvar (0.2.0)
-      ractor-tvar (~> 0.3.0)
+    ractor-tmvar (0.4.0)
+      ractor-sharing (~> 0.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    ast (2.4.1)
-    parallel (1.20.1)
-    parser (2.7.2.0)
+    ast (2.4.3)
+    json (3.0.2)
+    language_server-protocol (3.17.0.6)
+    lint_roller (1.1.0)
+    parallel (1.28.0)
+    parser (3.3.12.0)
       ast (~> 2.4.1)
-    power_assert (1.2.0)
-    ractor-tvar (0.3.0)
-    rainbow (3.0.0)
-    rake (13.0.1)
-    regexp_parser (2.0.0)
-    rexml (3.2.4)
-    rubocop (0.93.1)
-      parallel (~> 1.10)
-      parser (>= 2.7.1.5)
+      racc
+    power_assert (3.1.0)
+    prism (1.9.0)
+    racc (1.8.1)
+    ractor-sharing (0.3.0)
+    rainbow (3.1.1)
+    rake (13.4.2)
+    regexp_parser (2.13.1)
+    rubocop (1.91.0)
+      json (>= 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (>= 1.10)
+      parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8)
-      rexml
-      rubocop-ast (>= 0.6.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 2.0)
-    rubocop-ast (1.2.0)
-      parser (>= 2.7.1.5)
-    ruby-progressbar (1.10.1)
-    test-unit (3.3.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.50.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-rake (0.7.1)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.72.1)
+    ruby-progressbar (1.13.0)
+    test-unit (3.7.8)
       power_assert
-    unicode-display_width (1.7.0)
+    unicode-display_width (3.3.0)
+      unicode-emoji (~> 4.3)
+    unicode-emoji (4.3.0)
 
 PLATFORMS
   ruby
+  x86_64-linux
 
 DEPENDENCIES
   ractor-tmvar!
   rake (~> 13.0)
-  rubocop (~> 0.80)
+  rubocop (~> 1.91)
+  rubocop-rake (~> 0.7)
   test-unit (~> 3.0)
 
+CHECKSUMS
+  ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
+  bundler (4.0.16) sha256=d6ca5dd440c24f9abce9844cf44cc8e18c6a553de65a47efb4544137af92c47d
+  json (3.0.2) sha256=8e6d7e7b11384c21230430cef90b71f14849a34a1f4452796670f7c981bd19df
+  language_server-protocol (3.17.0.6) sha256=5ef2c0c138f8267e1bc631d3328347d354f96724b0af22f2c79516120443b7f0
+  lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87
+  parallel (1.28.0) sha256=33e6de1484baf2524792d178b0913fc8eb94c628d6cfe45599ad4458c638c970
+  parser (3.3.12.0) sha256=21a6d7f755d5a24dfbdc6e6b772e4e879a52e7631a88bc5a3a134606052c9828
+  power_assert (3.1.0) sha256=fefe98ed5d3140628138f3f9f9194d6ece01f1320e69700d3c928adca7518251
+  prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
+  racc (1.8.1) sha256=4a7f6929691dbec8b5209a0b373bc2614882b55fc5d2e447a21aaa691303d62f
+  ractor-sharing (0.3.0) sha256=9adb2f899e4e38f477a2d3c02368e8ff40be96b119172312253338ee1e22f63f
+  ractor-tmvar (0.4.0)
+  rainbow (3.1.1) sha256=039491aa3a89f42efa1d6dec2fc4e62ede96eb6acd95e52f1ad581182b79bc6a
+  rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
+  regexp_parser (2.13.1) sha256=5aedb6b7c35688f51e86eef17a15374dfd287c83f4ca644b2c5f3ec50a33b44b
+  rubocop (1.91.0) sha256=9c82b7bf391c5d7e3798c5b9996e22a1fe3bd7468e351dfdeb96140c058296d0
+  rubocop-ast (1.50.0) sha256=b9ca88300da0803ee222ad20cdb30494c0a784eed06fdc35d254b06d662788db
+  rubocop-rake (0.7.1) sha256=3797f2b6810c3e9df7376c26d5f44f3475eda59eb1adc38e6f62ecf027cbae4d
+  ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33
+  test-unit (3.7.8) sha256=689d1ca53f4d46f678b4e5d68d8e4294f87fc5e8b9238cc4de7c5727e8d65943
+  unicode-display_width (3.3.0) sha256=4b7aa66a4b11db50f6f7e98411215cd0dd10eaecb665d36eec5bcacb3fa0b613
+  unicode-emoji (4.3.0) sha256=11c02fa73290378c066bb0562cd4c87d8e1b706fbbe0059ca12746a4244de8ce
+
 BUNDLED WITH
-   2.2.0.rc.2
+  4.0.16

data/README.md

@@ -1,6 +1,6 @@
 # Ractor::TMVar
 
-TMVar for Ractor inspired by [Haskell's TMVar](https://hackage.haskell.org/package/stm-2.5.0.0/docs/Control-Concurrent-STM-TMVar.html) based on [Ractor::TVar](https://github.com/ko1/ractor-tvar).
+TMVar for Ractor inspired by [Haskell's TMVar](https://hackage.haskell.org/package/stm-2.5.0.0/docs/Control-Concurrent-STM-TMVar.html) based on [Ractor::TVar](https://github.com/ko1/ractor-sharing/blob/main/docs/tvar.md).
 
 ## Installation
 
@@ -20,11 +20,8 @@ Or install it yourself as:
 
 ## Usage
 
-Please see [Ractor::TVar](https://github.com/ko1/ractor-tvar) before using this.  
-Now we have only `value` and `value=` operations.
-
 ```ruby
-require 'ractor-tmvar'
+require 'ractor/tmvar'
 
 tv1 = Ractor::TMVar.new(0)
 tv2 = Ractor::TMVar.new(0)
@@ -33,27 +30,91 @@ rs = 100.times.map do
     value1 = nil
     value2 = nil
     Ractor.atomically do
-      # take value similar to takeTMVar in Haskell
-      value1 = v1.value
-      value2 = v2.value
+      # take value like takeTMVar in Haskell
+      value1 = v1.take
+      value2 = v2.take
     end
     Ractor.atomically do
-      # set value similar to putTMVar in Haskell
-      v2.value = value2 + 2
-      v1.value = value1 + 1
+      # set value like putTMVar in Haskell
+      v2.put(value2 + 2)
+      v1.put(value1 + 1)
     end
   end
 end
-rs.each(&:take)
-assert_equal 100, tv1.value
-assert_equal 200, tv2.value
+rs.each(&:value)
+
+tv1.read #=> 100
+tv2.read #=> 200
+```
+
+`Ractor::TMVar.new` creates an empty variable, while `Ractor::TMVar.new(value)` or
+`Ractor::TMVar.new_filled(value)` creates a variable already containing `value`.
+`nil` can be stored as a normal value:
+
+```ruby
+tv = Ractor::TMVar.new_filled(nil)
+tv.empty? #=> false
+tv.read   #=> nil
+```
+
+### Transactional operations
+
+`take`, `put`, `swap`, `try_take`, and `try_put` must be called inside `Ractor.atomically`. `read` and
+`empty?` can be called outside of a transaction.
+
+```ruby
+tv = Ractor::TMVar.new
+Ractor.atomically { tv.put(42) }
+Ractor.atomically { tv.take } #=> 42
+```
+
+### Non-blocking try operations
+
+`try_take` and `try_read` never retry. Without a block, they return the stored
+value, or `nil` when empty. With a block, when the variable is
+empty they return `nil` without calling the block. When it is full they yield the
+stored value and return the block's result, so a stored `nil` can be told apart
+from an empty variable. `try_take` empties the variable before yielding;
+`try_read` leaves it full.
+
+```ruby
+tv = Ractor::TMVar.new(5)
+
+tv.try_read { |v| v * 2 } #=> 10
+tv.read                   #=> 5
+
+Ractor.atomically { tv.try_take { |v| v * 2 } } #=> 10
+tv.empty?                                        #=> true
+
+empty = Ractor::TMVar.new
+Ractor.atomically { empty.try_take { |v| [v] } } #=> nil (block not called)
+
+filled_with_nil = Ractor::TMVar.new_filled(nil)
+filled_with_nil.try_read { |v| [v] } #=> [nil]
+```
+
+`try_put` returns `true` when it stored the value and `false` when the variable
+was already full.
+
+```ruby
+tv = Ractor::TMVar.new
+Ractor.atomically { tv.try_put(1) } #=> true
+Ractor.atomically { tv.try_put(2) } #=> false
 ```
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Verifying gem provenance
+
+Verify a downloaded gem's build provenance attestation with the GitHub CLI:
+
+```sh
+gh attestation verify ractor-tmvar-0.3.0.gem -R yoshitsugu/ractor-tmvar
+```
 
 ## Contributing
 

data/lib/ractor/tmvar/version.rb

@@ -2,6 +2,6 @@
 
 class Ractor
   class TMVar
-    VERSION = "0.2.0"
+    VERSION = "0.4.0"
   end
 end

data/lib/ractor/tmvar.rb

@@ -1,126 +1,229 @@
 # frozen_string_literal: true
 
 require "ractor/tvar"
+require_relative "tmvar/version"
 
 class Ractor
-  # TMVar for Ractor inspired by Haskell's TMVar based on Ractor::TVar.
+  # Transactional MVar-like variable for Ractor, inspired by Haskell's
+  # +Control.Concurrent.STM.TMVar+ and built on Ractor::TVar.
+  #
+  # A TMVar is either empty or full. When full it holds a single value.
+  # Reading and writing operations are transactional through {Ractor.atomically}.
+  #
+  # The implementation stores +nil+ when empty and a single-element array +[value]+
+  # when full, so any Ruby object (including +nil+) can be stored without colliding
+  # with the empty state.
   class TMVar
     #
-    # represents "empty" value for TMVar
+    # Create a new TMVar.
     #
-    EMPTY = :RACTOR_TMVAR_EMPTY
+    # @overload initialize
+    #   Creates an empty TMVar (Haskell's +newEmptyTMVar+).
+    # @overload initialize(value)
+    #   Creates a TMVar filled with +value+ (Haskell's +newTMVar+).
+    #   @param [Object] value value to store. With ractor-sharing 0.3, the value is
+    #     automatically made Ractor-shareable and the passed object is frozen.
+    #     This behavior is provided by the upstream Ractor::TVar, not a TMVar guarantee.
+    #
+    # @raise [ArgumentError] if more than one argument is given.
+    #
+    def initialize(*args)
+      raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0..1)" if args.size > 1
+
+      @tvar = Ractor::TVar.new(args.empty? ? nil : [args[0]])
+    end
 
     #
-    # initialize TMVar
+    # Create a new TMVar explicitly filled with +value+.
     #
-    # @param [Object] value Value to set TVar. It needs to be shareable.
+    # This is equivalent to +TMVar.new(value)+ but makes the intent clear when the
+    # stored value might be +nil+.
+    #
+    # @param [Object] value value to store. With ractor-sharing 0.3, the value is
+    #   automatically made Ractor-shareable and the passed object is frozen.
+    #   This behavior is provided by the upstream Ractor::TVar, not a TMVar guarantee.
     #
     # @return [TMVar]
     #
-    def initialize(value = nil)
-      @tvar = Ractor::TVar.new(value)
+    def self.new_filled(value)
+      new(value)
     end
 
     #
-    # get the value and leave the value to "empty"
-    # If the value is already "empty", it will retry the transaction.
-    # @note You need to wrap it by Ractor.atomically even if you only call +take+
-    #       because +TVar#value=+ needs atomically.
+    # Take the value, leaving the TMVar empty.
+    #
+    # If the TMVar is empty, the transaction is retried.
+    #
+    # @note Must be called inside {Ractor.atomically}.
     #
-    # @return [Object] value of internal TVar.
+    # @return [Object] the stored value.
     #
     def take
-      v = @tvar.value
-      raise Ractor::RetryTransaction if v == EMPTY
+      cell = @tvar.value
+      raise Ractor::RetryTransaction if cell.nil?
 
-      @tvar.value = EMPTY
-      v
+      @tvar.value = nil
+      cell[0]
     end
 
     #
-    # try to get the value.
-    # If the value is "empty", it returns nil.
+    # Try to take the value without retrying.
     #
-    # @return [Object] value of internal TVar, only if exists.
+    # If the TMVar is empty, returns +nil+ without calling the block.
+    # If the TMVar is full, empties it, yields the value and returns the block's result.
+    # Without a block, returns the stored value unchanged.
+    # Because the block is called only when full, a stored +nil+ can be told apart
+    # from an empty TMVar.
     #
-    def try_take
-      v = @tvar.value
-      return nil if v == EMPTY
+    # @note Must be called inside {Ractor.atomically}.
+    #
+    # @overload try_take
+    #   @return [Object, nil] the stored value, or +nil+ if empty.
+    # @overload try_take { |value| ... }
+    #   @yieldparam value [Object] the stored value, including +nil+.
+    #   @yieldreturn [Object] the value to return from +try_take+.
+    #   @return [Object, nil] the block's result, or +nil+ if empty.
+    #
+    # @example Take a value without a block
+    #   tv = Ractor::TMVar.new(5)
+    #   Ractor.atomically { tv.try_take } #=> 5
+    #   tv.empty? #=> true
+    #
+    # @example Distinguish a stored nil from an empty TMVar
+    #   tv = Ractor::TMVar.new(nil)
+    #   Ractor.atomically { tv.try_take { |value| [value] } } #=> [nil]
+    #   Ractor.atomically { tv.try_take { |value| [value] } } #=> nil
+    #
+    def try_take(&block)
+      cell = @tvar.value
+      return nil if cell.nil?
 
-      @tvar.value = EMPTY
-      v
+      @tvar.value = nil
+      (block || method(:identity)).call(cell[0])
     end
 
     #
-    # get the value like +take+.
-    # The difference between +take+ and +read+ is +take+ leaves the value blank,
-    # but +read+ not change the value to blank.
+    # Read the value, leaving the TMVar full.
     #
-    # @return [Object] value of internal TVar.
+    # If the TMVar is empty, the transaction is retried.
+    # It can also be called outside {Ractor.atomically}.
+    #
+    # @return [Object] the stored value.
     #
     def read
-      v = @tvar.value
-      raise Ractor::RetryTransaction if v == EMPTY
+      cell = @tvar.value
+      raise Ractor::RetryTransaction if cell.nil?
 
-      v
+      cell[0]
     end
 
     #
-    # read the value like +read+ but it does not retry.
+    # Try to read the value without retrying.
+    #
+    # If the TMVar is empty, returns +nil+ without calling the block.
+    # If the TMVar is full, yields the value and returns the block's result.
+    # Without a block, returns the stored value unchanged.
+    # The TMVar remains full.
+    #
+    # @note Can be called outside {Ractor.atomically}.
     #
-    # @return [Object] value of internal TVar.
+    # @overload try_read
+    #   @return [Object, nil] the stored value, or +nil+ if empty.
+    # @overload try_read { |value| ... }
+    #   @yieldparam value [Object] the stored value, including +nil+.
+    #   @yieldreturn [Object] the value to return from +try_read+.
+    #   @return [Object, nil] the block's result, or +nil+ if empty.
     #
-    def try_read
-      v = @tvar.value
-      v == EMPTY ? nil : v
+    # @example Read or transform a value without removing it
+    #   tv = Ractor::TMVar.new(5)
+    #   tv.try_read #=> 5
+    #   tv.try_read { |value| value * 2 } #=> 10
+    #   tv.read #=> 5
+    #
+    # @example Distinguish a stored nil from an empty TMVar
+    #   Ractor::TMVar.new(nil).try_read { |value| [value] } #=> [nil]
+    #   Ractor::TMVar.new.try_read { |value| [value] } #=> nil
+    #
+    def try_read(&block)
+      cell = @tvar.value
+      return nil if cell.nil?
+
+      (block || method(:identity)).call(cell[0])
     end
 
     #
-    # write the given value.
-    # If the current value is not "empty", it retries the transaction.
+    # Put a value into the TMVar.
+    #
+    # If the TMVar is already full, the transaction is retried.
     #
-    # @param [Object] new_value neet to be shareable
+    # @note Must be called inside {Ractor.atomically}.
+    #
+    # @param [Object] new_value value to store. With ractor-sharing 0.3, the value is
+    #   automatically made Ractor-shareable and the passed object is frozen.
+    #   This behavior is provided by the upstream Ractor::TVar, not a TMVar guarantee.
+    #
+    # @return [Object] +new_value+.
     #
     def put(new_value)
-      raise Ractor::RetryTransaction if @tvar.value != EMPTY
+      raise Ractor::RetryTransaction unless @tvar.value.nil?
 
-      @tvar.value = new_value
+      @tvar.value = [new_value]
+      new_value
     end
 
     #
-    # try to put value to TVar's value
-    # If the value is not "empty", it will not retry and only return false.
-    # If it succeed to put, it returns true.
+    # Try to put a value into the TMVar without retrying.
+    #
+    # @note Must be called inside {Ractor.atomically}.
     #
-    # @param [Object] new_value neet to be shareable
+    # @param [Object] new_value value to store. With ractor-sharing 0.3, the value is
+    #   automatically made Ractor-shareable and the passed object is frozen.
+    #   This behavior is provided by the upstream Ractor::TVar, not a TMVar guarantee.
+    #
+    # @return [Boolean] +true+ if the value was stored, +false+ if the TMVar was full.
     #
     def try_put(new_value)
-      return false if @tvar.value != EMPTY
+      return false unless @tvar.value.nil?
 
-      @tvar.value = new_value
+      @tvar.value = [new_value]
       true
     end
 
     #
-    # return the value is "empty" or not.
+    # Return whether the TMVar is currently empty.
+    # It can also be called outside {Ractor.atomically}.
     #
-    # @param [Boolean]
+    # @return [Boolean]
     #
     def empty?
-      @tvar.value == EMPTY
+      @tvar.value.nil?
     end
 
     #
-    # get the the value like +get+, and replace the value to the given value if the current value is not "empty"
+    # Replace the stored value and return the previous value.
+    #
+    # If the TMVar is empty, the transaction is retried.
+    #
+    # @note Must be called inside {Ractor.atomically}.
+    #
+    # @param [Object] new_value value to store. With ractor-sharing 0.3, the value is
+    #   automatically made Ractor-shareable and the passed object is frozen.
+    #   This behavior is provided by the upstream Ractor::TVar, not a TMVar guarantee.
     #
-    # @param [Object] new_value neet to be shareable
+    # @return [Object] the previous value.
     #
-    def swap(new)
-      v = @tvar.value
-      raise Ractor::RetryTransaction if v == EMPTY
+    def swap(new_value)
+      cell = @tvar.value
+      raise Ractor::RetryTransaction if cell.nil?
+
+      @tvar.value = [new_value]
+      cell[0]
+    end
+
+    private
 
-      @tvar.value = new
-      v
+    def identity(value)
+      value
     end
   end
 end

data/ractor-tmvar.gemspec

@@ -12,13 +12,14 @@ Gem::Specification.new do |spec|
   spec.description   = "Introduce Ractor::TMVar based on Ractor::TVar"
   spec.homepage      = "https://github.com/yoshitsugu/ractor-tmvar"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.2")
+  spec.required_ruby_version = Gem::Requirement.new(">= 4.0")
 
   # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
   spec.metadata["changelog_uri"] = spec.homepage
+  spec.metadata["rubygems_mfa_required"] = "true"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -29,5 +30,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "ractor-tvar", "~> 0.3.0"
+  spec.add_dependency "ractor-sharing", "~> 0.3.0"
 end

metadata

@@ -1,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: ractor-tmvar
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - yoshitsugu
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ractor-tvar
+  name: ractor-sharing
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -31,7 +30,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/build-gem.yml"
 - ".github/workflows/main.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - Gemfile
@@ -51,7 +52,7 @@ metadata:
   homepage_uri: https://github.com/yoshitsugu/ractor-tmvar
   source_code_uri: https://github.com/yoshitsugu/ractor-tmvar
   changelog_uri: https://github.com/yoshitsugu/ractor-tmvar
-post_install_message:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -59,15 +60,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.2
+      version: '4.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.0.rc.2
-signing_key:
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Ractor::TMVar
 test_files: []