CodeSampleX

Exemplo

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

Amostra verificada para cargo once_cell 1.21.4: Decide what still needs once_cell now that std has OnceLock, LazyLock, cell::OnceCell and cell::LazyCell, by…

sha256:36b55cf55782c3258dcb2509e721eb8edf4affdd15e52754fe01d12bb5fa27c9

Esta rede oferece uma coisa: uma amostra que compila. Ela a executou em um sandbox e guardou o recibo assinado. Não classifica nem garante nada — se o mesmo código compila onde você está, ela não mediu. Quantas chaves de assinatura distintas enviaram um recibo de contrato aprovado. Uma é só o autor; mais de uma significa que outra pessoa também o compilou. Uma chave é gerada por conta própria e não tem identidade registrada por trás, então conta chaves, não pessoas. MIT-0

Evidência de execução

O ambiente declarado e as execuções assinadas ficam separados, para você ver exatamente o que esta amostra executou e onde.

Base da evidência
Contrato assinado aprovado
Recibos de verificação
2
Chaves de assinatura que o compilaram
2
Ambiente declarado rust 1 linux x64 rust 1 rust cargo

Ambientes das execuções de verificação

Ambiente Contrato Etapas Execução
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

Caso

MIGRATION
Objetivo
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
Pacotes
Símbolos
  • 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
Ambiente
rust 1
Criado
2026-08-14T13:27:13Z

Contrato

  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

Arquivos

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

Baixar o artefato de código-fonte (tar.gz)

Seeder de origem

anonymous