CodeSampleX

Beispiel

once_cell 1.21.4: Decide what still needs once_cell now that std has OnceLock, LazyLock, cell::OnceCell and cell::LazyCell, by measuring which once_cell APIs have a stable std equivalent on this rustc and which are still gated

Verifiziertes Beispiel für cargo once_cell 1.21.4: Decide what still needs once_cell now that std has OnceLock, LazyLock, cell::OnceCell and cell::LazyCell…

sha256:36b55cf55782c3258dcb2509e721eb8edf4affdd15e52754fe01d12bb5fa27c9

Dieses Netzwerk bietet eine Sache: ein Sample, das baut. Es hat es in einer Sandbox ausgeführt und die signierte Quittung behalten. Es bewertet nichts und garantiert nichts — ob derselbe Code bei Ihnen baut, hat es nicht gemessen. Wie viele verschiedene Signaturschlüssel eine bestandene Vertragsquittung eingereicht haben. Einer ist der Autor allein; mehr als einer heißt, jemand anderes hat es auch gebaut. Ein Schlüssel wird selbst erzeugt und hat keine registrierte Identität dahinter — gezählt werden Schlüssel, nicht Personen. MIT-0

Ausführungsbelege

Die deklarierte Umgebung und die signierten Läufe stehen getrennt, damit Sie genau sehen, was dieses Sample ausgeführt hat und wo.

Beleggrundlage
Signierter Vertrag bestanden
Verifizierungsbelege
2
Signaturschlüssel, die es gebaut haben
2
Deklarierte Umgebung rust 1 linux x64 rust 1 rust cargo

Umgebungen der Verifizierungsläufe

Umgebung Contract Stufen Lauf
rust 1 · linux alpine/x64 · docker ed25519:a2ec939a4c60e243 PASS compile:SKIPPED · contract:PASS · load:PASS · resolve:PASS
CONTAINER_RUN · cargo@1		 2026-08-14
rust 1 · linux alpine/x64 · docker ed25519:d91480838ac982c9 PASS compile:SKIPPED · contract:PASS · load:PASS · resolve:PASS
CONTAINER_RUN · cargo@1		 2026-08-18

Fall

MIGRATION
Ziel
Decide what still needs once_cell now that std has OnceLock, LazyLock, cell::OnceCell and cell::LazyCell, by measuring which once_cell APIs have a stable std equivalent on this rustc and which are still gated
Pakete
Symbole
  • std::sync::OnceLock
  • OnceLock::set
  • OnceLock::get_or_init
  • OnceLock::take
  • std::sync::LazyLock
  • LazyLock::force
  • LazyLock::force_mut
  • std::cell::OnceCell
  • std::cell::LazyCell
  • once_cell::sync::OnceCell
  • once_cell::sync::OnceCell::get_or_try_init
  • once_cell::sync::Lazy
  • once_cell::unsync::OnceCell
Umgebung
rust 1
Erstellt
2026-08-14T13:27:13Z

Contract

  1. assert a second OnceLock::set neither panics nor overwrites, and hands the rejected value straight back inside Err while the first value stays put
  2. assert get_or_init on an already filled cell never calls its closure, and that take() needs &mut so a shared cell stays write-once
  3. assert once_cell::sync::OnceCell::set has the identical hands-it-back contract
  4. assert get_or_init runs its closure exactly once when 16 threads arrive together, counted with an AtomicUsize, and that every thread leaves with the winner's value
  5. assert set() called by the same 16 threads instead runs 16 times, returns exactly one Ok, and hands every loser its own value back rather than the winner's
  6. assert a LazyLock static has not run its initialiser before the first deref, and runs it exactly once across 8 threads doing 1000 lookups each
  7. assert LazyLock::force hands back the same allocation as deref, and that once_cell::sync::Lazy builds the same table with the same laziness
  8. assert std LazyLock implements DerefMut and force_mut on this rustc, so neither is a once_cell-only feature any more
  9. assert a const LazyLock compiles and re-runs its initialiser once per use site: three uses, three builds, no warning
  10. assert once_cell::sync::Lazy in a const does exactly the same, so the trap belongs to const and not to the crate
  11. assert the same three uses of a static LazyLock build once and hand out a single address
  12. assert std::cell::OnceCell and std::cell::LazyCell cover once_cell::unsync, with the same set/get contract and the same first-use laziness
  13. assert the measured sizes: the unsync cell saves nothing over OnceLock for a u32 and eight bytes for a String
  14. compile a probe file with rustc to prove OnceLock::get_or_try_init is E0658 behind the once_cell_try feature, tracking issue 109737
  15. compile a probe file with rustc to prove OnceLock::try_insert is E0658 behind the once_cell_try_insert feature
  16. compile probe files with rustc to prove OnceLock::wait and LazyLock::force_mut do compile on this rustc
  17. compile a probe file with rustc to prove std::cell::OnceCell is not Sync, with rustc naming std::sync::OnceLock as the replacement
  18. assert once_cell's get_or_try_init leaves the cell empty after a failed init so the next caller retries, and stops calling the closure once one succeeds
  19. assert the hand-rolled get-then-set stand-in runs its initialiser once per thread, 16 out of 16, while still handing every caller the same value

Dateien

  • Cargo.lock
  • Cargo.toml
  • csx.json
  • src/main.rs

Quellartefakt herunterladen (tar.gz)

Ursprungs-Seeder

anonymous