313 lines
135 KiB
Plaintext
313 lines
135 KiB
Plaintext
|
rust
|
|||
|
|
v #rustc 1.96.0 (ac68faa20 2026-05-25)ÁÀ뉊 ]!ÜÛê(¹Þ—šên -5be7b69c3ff7b5b8Á íàÄTËŸ ÜJîÄ)'ß\¥! -3d1337db07d0b3aeÁ ¤²XctÔ'ÐÓ©z¨É½Ó -a4945860e1c53b00Á ¤°ð ¾ä-±($²ï=©Ã -7e98a21bfd32b0edÁ–�òÖÀH•‘P IÓHã#£ -055f30b747f859b6Á rustc_std_workspace_coreÁCçß^ò½èÝ$Çÿ+Cé -c4878ee60b2242c9Á ŸÃï+Ñ]ŠqB<ÏïW# -8dd1dd90e70d0b6aÁ miniz_oxideÁ€š»J(P>àö÷g\K -1eb618da2918ab7fÁ adler2ÁÆ;+Þ®5¥ÌýÝ°¦ÛLˆ -f7919172d268e069Á hashbrownÁPäV9ÒÆèÜ�"ÊÖVŽ\ -0fc2184a5da6723aÁ rustc_std_workspace_allocÁs&ØòØy¯s•bæ!‰ýŠ -97e4bf30be240674Á
|
|||
|
|
std_detectÁhŠBîÙºÌI®Ë�Å�š -9dbbf8346ba7ac8bÁ rustc_demangleÁûë9´Ç×@Œ�’ùXFº -f33013f239bf9f14Á cfg_ifÁÜLh�ž§Œaã¯>� -0a71c8f33a838301Á addr2lineÁ׎Þ!]8V$É@@T· -e618e6be60e87ba2Á gimliÁ¸
|
|||
|
|
°µ~Î1‹Ñt ðÁ€w -1f7768a68858f670Á objectÁ
|
|||
|
|
áPÃ?À¶¼QHJ¥� -914cd6a4dbe590d1Á memchrÁ›º«8Ór2Ù $¨ûib‚ -cf21ca6f2bb15dcdÁë
|
|||
|
|
‹ás «LÖ€îâƒ×ɯŒ -ee6f3747e38367f0Á impÁ e » critical-sectionÁäÝd Å ƒf » parking_lotÁ¼Îe testsÁ,ÕL‚ $ÊL… atomicÁ4¢
|
|||
|
|
» portable-atomicÁÜí À ¤ Å
|
|||
|
|
|
|||
|
|
¥ ¥ ¥ ¥ ¥ æ
|
|||
|
|
with_valueÁ is_initializedÁ
|
|||
|
|
initializeÁ — – waitÁ
|
|||
|
|
get_uncheckedÁ get_mutÁ
|
|||
|
|
into_innerÁ
|
|||
|
|
INCOMPLETEÁ RUNNINGÁ COMPLETEÁ INCOMPLETE_PTRÁ COMPLETE_PTRÁ
|
|||
|
|
STATE_MASKÁ WaiterÁ .Š . signaledÁ .ó GuardÁ 2 'aÁ 2 queueÁ 2 new_queueÁ 6ã 7 initialize_or_waitÁ 9 °
|
|||
|
|
; ; strictÁ > addrÁ ?¥ > with_addrÁ A¥ > map_addrÁ C¥ C impl FnOnce(usize) -> usizeÁ unsyncÁ F FFFFFFFFF F
|
|||
|
|
F F OnceCellÁ S¥ S innerÁ F V¥ FX¥ FZ¥ Z> F]¥ ]× F`¥ `ƒ `† Fd¥ d� Fg¥ Fi¥ i÷ Fl¥ læ lç l getÁ lÏ
|
|||
|
|
l setÁ l
|
|||
|
|
try_insertÁ l get_or_initÁ t— t VoidÁ t l get_or_try_initÁ x— x– l takeÁ lÝ
|
|||
|
|
F LazyÁ }¥ }— } cellÁ } initÁ F ‚¥ ‚— F
|
|||
|
|
…¥ …— …× F ‰¥ ‰— ‰æ ‰
|
|||
|
|
into_valueÁ � Ž F �¥ �— � forceÁ “ � force_mutÁ • �Ò �Ï
|
|||
|
|
F
|
|||
|
|
™¥ ™— ™å ™´ Fž¥ ž— ž¶ F¢¥ ¢> ç ¥ ¥¥¥¥¥¥¥¥¥– ¯
|
|||
|
|
¯¥ ¯ˆ ¥ ³¥ ³> ¥¶¥ ¶× ¥¹¥ ¹ƒ ¹† ¥½¥ ½÷ ¥À¥ À� ¥Ã¥ ¥Å¥ Åæ Åç ÅÒ Å°
|
|||
|
|
ÅÏ
|
|||
|
|
Å»
|
|||
|
|
Åã Åí Î Åþ З З РŦ Ô— Ô– ÅÊ ÅÝ
|
|||
|
|
¥Ü Ù¥ Ù— Ùõ Ù€ ¥Þ¥ Þ— Þ× ¥â¥ â— ¥ å¥ å— ¥
|
|||
|
|
è¥ è— èæ èØ ì í ¥ ï¥ ï— ïˆ ò ïš ô ïÒ ïÏ
|
|||
|
|
¥ ø¥ ø— øå ø´ ¥
|
|||
|
|
ý¥ ý— ý¶ ¥�¥ �> ¥ _dummyÁ raceÁ … ……………………… �æ �Ò �»
|
|||
|
|
’ as_const_ptrÁ “ “ _ALIGNMENT_COMPATIBLEÁ �ã �þ —— —— — �¦ ›— ›– �€ ž– ž (impl FnOnce() -> Result<NonZeroUsize, E>Á � …¢æ ¢Ò ¢ã ¢þ ¦— ¦ ¢¦ ©— ©– © ¢€ ¢ to_usizeÁ … OnceRefÁ ¯‹ ¯¥ ¯¬ ¯ ghostÁ …´‹ ´¥ …·‹ ·¥ ·× …»‹ »¥ »> …¿‹ ¿¥ ¿æ ¿Ò ¿ã ¿þ Å— Å— Å ¿¦ É— É– ¿€ Ì– Ì !impl FnOnce() -> Result<&'a T, E>Á ¿ Ï ¿« … … once_boxÁ Ó ÓÓÓÓÓÓÓ OnceBoxÁ Û¥ Û¬ Û× Ó ß¥ ß× Ó⥠â> Óå¥ åã Óè¥ èæ èç èÒ èã èþ î— î— î è¦ ò— ò– è€ õ– õ "impl FnOnce() -> Result<Box<T>, E>Á Óø¥ Óú¥ úƒ Ó« – þ¥ þ” þ» ‚¥ ‚× … OnceNonZeroUsizeÁ …¬ …‡> …‰× … OnceBoolÁ ‹¬ …�> … �×
|
|||
|
|
|
|||
|
|
$
|
|||
|
|
%
|
|||
|
|
&
|
|||
|
|
6
|
|||
|
|
7
|
|||
|
|
9
|
|||
|
|
9
|
|||
|
|
;
|
|||
|
|
_
|
|||
|
|
_
|
|||
|
|
_
|
|||
|
|
b
|
|||
|
|
c
|
|||
|
|
c
|
|||
|
|
f
|
|||
|
|
f
|
|||
|
|
p
|
|||
|
|
q
|
|||
|
|
r
|
|||
|
|
s
|
|||
|
|
t
|
|||
|
|
x
|
|||
|
|
{
|
|||
|
|
ˆ
|
|||
|
|
ˆ
|
|||
|
|
ˆ
|
|||
|
|
“
|
|||
|
|
•
|
|||
|
|
—
|
|||
|
|
˜
|
|||
|
|
�
|
|||
|
|
¡
|
|||
|
|
¸
|
|||
|
|
¸
|
|||
|
|
¸
|
|||
|
|
»
|
|||
|
|
¼
|
|||
|
|
¼
|
|||
|
|
Â
|
|||
|
|
Â
|
|||
|
|
É
|
|||
|
|
Ê
|
|||
|
|
Ë
|
|||
|
|
Ì
|
|||
|
|
Í
|
|||
|
|
Î
|
|||
|
|
Ð
|
|||
|
|
Ô
|
|||
|
|
×
|
|||
|
|
á
|
|||
|
|
á
|
|||
|
|
á
|
|||
|
|
ò
|
|||
|
|
ô
|
|||
|
|
ö
|
|||
|
|
÷
|
|||
|
|
ü
|
|||
|
|
€
|
|||
|
|
‘
|
|||
|
|
’
|
|||
|
|
“
|
|||
|
|
–
|
|||
|
|
—
|
|||
|
|
›
|
|||
|
|
ž
|
|||
|
|
¡
|
|||
|
|
¤
|
|||
|
|
¥
|
|||
|
|
¦
|
|||
|
|
©
|
|||
|
|
º
|
|||
|
|
º
|
|||
|
|
º
|
|||
|
|
Ã
|
|||
|
|
Ä
|
|||
|
|
Å
|
|||
|
|
É
|
|||
|
|
Ì
|
|||
|
|
Ï
|
|||
|
|
á
|
|||
|
|
á
|
|||
|
|
á
|
|||
|
|
ç
|
|||
|
|
ì
|
|||
|
|
í
|
|||
|
|
î
|
|||
|
|
ò
|
|||
|
|
õ
|
|||
|
|
ü
|
|||
|
|
„
|
|||
|
|
„
|
|||
|
|
„
|
|||
|
|
Š
|
|||
|
|
Š
|
|||
|
|
Š
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
¿c þ þ – €” �» Lƒµ)ÍŒBø ¥ � ½& Ìì½& ¬½½& «½½& Œ" 2 2 ÿ 4” 5 0|ö¾€˜Ö 8 ¬½ S S – U¬ F phñ"<×q4õ& «½î' ³ î' ¿cî' Øî' µßî'î' ™î' é î'õ& ¬½ } } Ü €õ F �€ F Œä©M¶ó0öõ&— ¿cñ( é!ñ( ö!ñ( ³ } } Ü €õ F �€ F Œä©M¶ó0öõ& õ& ³ ¯ ¯ °– ²ˆ ¥ ö›
|
|||
|
|
M3®õ& ¿cž* Øž* é ž*õ& µßž*ž* ™ž* ¿c Ù Ù Ü Üõ ¥ Ý€ ¥ †ü@ä+V—õ&ª) � “+ ¬½“+ é!“+ ö!“+ ³ Ù Ù Ü Üõ ¥ Ý€ ¥ †ü@ä+V—õ&Ž* ³ … … ø †¬ … -þÄÞXè6 ¿cÊ, ³ ‹ ‹ ±! Œ¬ … ¹žþ$«81i ¿c‰- � ¯ ¯ ° ²¬ … ³× … ÿŠZa.pI� ‹ ¥ ¿cÈ- ³ È- ¿c Û Û š ݬ Ó Þ× Ó `x41"Mëáõ& ³ ©. Œ"©. � ©. Ø©. ‚ þ] S… }¶ ¯Þ Ù‰ …� ‹· ¯ß Û þâ Ù´ ¯ø Û þ þV S‚ }å Ù þX S6 2å ÛZ S¢ }³ ¯� Ù‡ …� ‹» ¯â Û` S¹ ¯ú Ûd SÀ ¯g Sà ¯i S½ ¯™ }ø Ùž }ý Ù¿c ’� <Ì쬽«½Œ" ³ Ø5µß™ é é! ö!
|
|||
|
|
ô°
|
|||
|
|
|
|||
|
|
t°
|
|||
|
|
|
|||
|
|
Ò] . . Õ /Š 0é 1ó {ÏYhŸ‰Y t¿
|
|||
|
|
+ Œ2 x ¬×
|
|||
|
|
$ç
|
|||
|
|
Û¼ õ& %
|
|||
|
|
, |×
|
|||
|
|
|
|||
|
|
õ0ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙõ& ‚ “ ë
|
|||
|
|
üž
|
|||
|
|
P þ õ& í
|
|||
|
|
ô
|
|||
|
|
üë ‰ ½& \ˆ
|
|||
|
|
¤]¤] V ¦]Á‚] üß3ø¤”&Ö2 ¤ î0î0
|
|||
|
|
UnsafeCellÁ ð0»Ì- ·}—KEüC£¥3 h ¥3 h ¢– + Ö2 äÎ
|
|||
|
|
& ,
|
|||
|
|
3 tÎ †2dÝ , Ö2 Y äó \ƒ ,ˆ - Û¼õ& � U
|
|||
|
|
\ |ó Ÿ3 g x Ž ü¼ U þ õ& � — üú
|
|||
|
|
� – 3 ½& \¦ õ& ,™ Þ4 h “5 ¥3 õ& c »2 ƒ[ , Ö2 0x0Á ²9 0x1Á ²9 0x2ÁÌë" Të" ( ²9Ö2 üÇ"> + Ö2 \Ý" $9 ( ²9 _Á ¼¨# D¨# * ²9Ö2 ü†#: , Ö2 \š# $9 * ²9 _Á ²9 0x3Á¬ú{ $Š| Û¼ õ& %
|
|||
|
|
, |ú{ Ÿ3 7 H Ž| üè{) S õ& �| ›| ü¸{c n î' \Î{ “5 ¥ ¥3 ¤ 2 ä¢} \²} ,·} Û¼õ& ¼} C
|
|||
|
|
J |¢} Ÿ3 U f ½} ü�}0 S õ& ¿} Ê} üÑ|y o î' \ö| õ& ,é| “5 Ì ¥3 Ë õ& Ê »! O |ŠÆ ' -
|
|||
|
|
4 lŠÆ
|
|||
|
|
nõ& Q ¬¡Æ T«Æ $°Æ / Û¼ª) ´Æ Y
|
|||
|
|
` L¡Æ
|
|||
|
|
‚/ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙª) ¶ È µÆ üýÅ; } õ&ª) ·Æ ÂÆ üÇÅ{ ÁÆ Œ 5 ñ( TäÅ ª) $ØÅ î' Ê á.á. a ã.»Ì- IÜž�B2®Á@ ª Á@ © ª) ¨ ” €` ´ T£ù
|
|||
|
|
D£ù
|
|||
|
|
õ& , ¤šù ¯ õ& ù ¸ù Ç üêøN ž* \€ù ½& ´¶ú ,Æú
|
|||
|
|
$ |¶ú
|
|||
|
|
õ& 4 F Ëú üú ¯ õ& Ìú ×ú üîùi È ž* \“ú õ& ,†ú ½& µ õ& ³ » L |óÐ ' -
|
|||
|
|
4 lóÐ
|
|||
|
|
Çõ& R ”ŠÑ <”Ñ ™Ñ / Û¼ª) šÑ Y
|
|||
|
|
` LŠÑ »@ k } ›Ñ üæÐ8 Ù õ&ª) �Ñ ¨Ñ ü³Ðu §Ñ ë 5 “+ TÍÐ ª) ÄÐ ž* � ÇB 3 Á@ 2 ª) 1 g ±3 ‡ œÏ
|
|||
|
|
„Ï
|
|||
|
|
ŒÄ à ²9 > üÁ# … ã ê � üœN Ê, $² ¤]¤] V ¦]Á‚] üß3ø¤”&²9 · K üõ4 üõ/ Ìõ
|
|||
|
|
¼õ
|
|||
|
|
ÊçJ * œ‘
|
|||
|
|
Œ‘
|
|||
|
|
ʲ9 * e q ²9 … •
|
|||
|
|
£ » ¨ ²9 Ý $ Iª I© ü»p Q øIí=
|
|||
|
|
|
|||
|
|
|
|||
|
|
àW F
|
|||
|
|
3 • N ¬M Ø p ²9 o ²9 n ²9 H † x Ž _Á ¼ì2
|
|||
|
|
“2
|
|||
|
|
� ' üÞ2' ‹ „3 ‹3 £ ü¹2R ‰- $Ï2 Ê, s ü¬E |»E
|
|||
|
|
l»E
|
|||
|
|
²ˆ. * 7
|
|||
|
|
> t¬E
|
|||
|
|
Ò]ˆ. N _ ÊE \ÔE • î0î0 �4 ð0»Ì- ·}—KEüC£ ˆ. üžEC ¯ ˆ. àE çE  üùDn ¯ ¯ ° ²¬ … ³× … ÿŠZa.pI� ˆ. $�E ¤]¤] V ¦]Á‚] üß3ø¤”& ˆ. z ØR y • • – PhantomDataÁ Fu\»ŸäP P Ë ü¶c |Åc
|
|||
|
|
lÅc
|
|||
|
|
²õ& * 7
|
|||
|
|
> t¶c
|
|||
|
|
Ò]õ& N _ Ôc \Þc • ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ�� ž BoxÁ ¡ˆˆ ¢‰ˆ l }.xÏõ&çEçEèE GlobalÁ ¿±‡§í# ü¨cC Û õ& êc õc ê üÿbv ©. $•c ¤]¤] V ¦]Á‚] üß3ø¤”& õ& ½ ëV ¼ • • – øQ Fu\»Ÿ´T ˆ „ ´¨î ¯ õ& ° ) ž* 4 ½& ; B F¥…À ¤,Ëd ü Ùñ t # OverviewÁ ú üJ G `once_cell` provides two new cell-like types, [`unsync::OnceCell`] andÁ ü^P M [`sync::OnceCell`]. A `OnceCell` might store arbitrary non-`Copy` types, canÁ ü¯H E be assigned to at most once and provides direct access to the storedÁ üøK H contents. The core API looks *roughly* like this (and there's much moreÁ ´Ä inside, read on!):Á Û ú ”ß ```rust,ignoreÁ Ìò impl<T> OnceCell<T> {Á üŒ- * const fn new() -> OnceCell<T> { ... }Á üº8 5 fn set(&self, value: T) -> Result<(), T> { ... }Á üó+ ( fn get(&self) -> Option<&T> { ... }Á ,Ÿ }Á <¥ ```Á ú ü±M J Note that, like with [`RefCell`] and [`Mutex`], the `set` method requiresÁ üÿO L only a shared reference. Because of the single assignment restriction `get`Á üÏ= : can return a `&T` instead of `Ref<T>` or `MutexGuard<T>`.Á � ú ü‘N K The `sync` flavor is thread-safe (that is, implements the [`Sync`] trait),Á üà" while the `unsync` one is not.Á ƒ ú ü‡5 2 [`unsync::OnceCell`]: unsync/struct.OnceCell.htmlÁ ü½1 . [`sync::OnceCell`]: sync/struct.OnceCell.htmlÁ üïG D [`RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.htmlÁ ü·C @ [`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.htmlÁ üûB ? [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.htmlÁ ¾ ú lÂ
|
|||
|
|
# RecipesÁ Ð ú üÔ 9 6 `OnceCell` might be useful for a variety of patterns.Á Ž
|
|||
|
|
ú ü’
|
|||
|
|
) & ## Safe Initialization of Global DataÁ ¼
|
|||
|
|
ú \À
|
|||
|
|
```rustÁ üÌ
|
|||
|
|
B ? # #[cfg(any(feature = "std", feature = "critical-section"))] {Á ¼� use std::{env, io};Á § ú ü« " use once_cell::sync::OnceCell;Á Î ú ¤Ò #[derive(Debug)]Á ¼ç pub struct Logger {Á tÿ // ...Á ,Ž Ë\ ü” 8 5 static INSTANCE: OnceCell<Logger> = OnceCell::new();Á Í ú ŒÑ impl Logger {Á üã , ) pub fn global() -> &'static Logger {Á ü�
|
|||
|
|
> ; INSTANCE.get().expect("logger is not initialized")Á LÏ
|
|||
|
|
}Á Ù
|
|||
|
|
ú üÝ
|
|||
|
|
H E fn from_cli(args: env::Args) -> Result<Logger, std::io::Error> {Á Œ¦ // ...Á ĸ # Ok(Logger {})Á LÑ ²h ,Û Ë\ á ú |å fn main() {Á üõ< 9 let logger = Logger::from_cli(env::args()).unwrap();Á ü²& # INSTANCE.set(logger).unwrap();Á üÙ- * // use `Logger::global()` from now onÁ ,‡ Ë\ <� # }Á <• Ù\ � ú ü¡# ## Lazy Initialized Global DataÁ Å ú üÉF C This is essentially the `lazy_static!` macro, but without a macro.Á � ú \” ¨d ü B ½d üã1 . use std::{sync::Mutex, collections::HashMap};Á • ú ü™" µe ¼ ú üÀ> ; fn global_data() -> &'static Mutex<HashMap<i32, String>> {Á üÿQ N static INSTANCE: OnceCell<Mutex<HashMap<i32, String>>> = OnceCell::new();Á üÑ! INSTANCE.get_or_init(|| {Á üó' $ let mut m = HashMap::new();Á ü›. + m.insert(13, "Spica".to_string());Á üÊ/ , m.insert(74, "Hoyten".to_string());Á Ìú Mutex::new(m)Á T” })Á ,Ÿ Ë\ <¥ Òk < Ù\ µ ú ü¹O L There are also the [`sync::Lazy`] and [`unsync::Lazy`] convenience types toÁ ä‰ streamline this pattern:Á ¦ ú \ª ¨d ü¶B ½d üù1 ©m ô« use once_cell::sync::Lazy;Á Ê ú üÎJ G static GLOBAL_DATA: Lazy<Mutex<HashMap<i32, String>>> = Lazy::new(|| {Á ü™# let mut m = HashMap::new();Á ü½* ' m.insert(13, "Spica".to_string());Á üè+ ( m.insert(74, "Hoyten".to_string());Á ¬” Mutex::new(m)Á <ª });Á ² ú |¶ �j üÆ6 3 println!("{:?}", GLOBAL_DATA.lock().unwrap());Á ,ý Ë\ <ƒ Òk <‹ Ù\ “ ú ü—K H Note that the variable that holds `Lazy` is declared as `static`, *not*Á üãP M `const`. This is important: using `const` instead compiles, but works wrong.Á ´ ú ü¸) & [`sync::Lazy`]: sync/struct.Lazy.htmlÁ üâ- * [`unsync::Lazy`]: unsync/struct.Lazy.htmlÁ � ú ü” & # ## General purpose lazy evaluationÁ » ú ü¿ = : Unlike `lazy_static!`, `Lazy` works with local variables.Á ý ú \� ¨d ü� use once_cell::unsync::Lazy;Á ® ú |² �j ü let ctx = vec![1, 2, 3];Á üã " let thunk = Lazy::new(|| {Á ü† # ctx.iter().sum::<i32>()Á \ª });Á ô¶ assert_eq!(*thunk, 6);Á ,Õ Ë\ <Û Ù\ ã ú üç L I If you need a lazy field in a struct, you probably should use `OnceCell`Á ü´ A > directly, because that will allow you to access `self` duringÁ œö initialization.Á Š ú \Ž ¨d üš ! use std::{fs, path::PathBuf};Á ¼ ú üÀ $ ! use once_cell::unsync::OnceCell;Á å ú „é
|
|||
|
|
struct Ctx {Á ìú config_path: PathBuf,Á ü˜!! config: OnceCell<String>,Á ,º! Ë\ À! ú tÄ! impl Ctx {Á üÓ!B ? pub fn get_config(&self) -> Result<&str, std::io::Error> {Á ü–"6 3 let cfg = self.config.get_or_try_init(|| {Á üÍ"5 2 fs::read_to_string(&self.config_path)Á „ƒ#
|
|||
|
|
})?;Á ä”# Ok(cfg.as_str())Á L±# ²h ,»# Ë\ <Á# Ù\ É# ú äÍ# ## Lazily Compiled RegexÁ ê# ú üî#H E This is a `regex!` macro which takes a string literal and returns anÁ ü·$6 3 *expression* that evaluates to a `&'static Regex`:Á î$ ú <ò$ Ù\
|
|||
|
|
deadlock.Á �R ú ü‘R& # **Does this crate support async?**Á ¸R ú ¼¼R No, but you can useÁ üÔRJ G [`async_once_cell`](https://crates.io/crates/async_once_cell) instead.Á ŸS ú ü£S) & **Does this crate support `no_std`?**Á ÍS ú üÑSJ G Yes, but with caveats. `OnceCell` is a synchronization primitive whichÁ üœTM J _semantically_ relies on blocking. `OnceCell` guarantees that at most oneÁ üêTM J `f` will be called to compute the value. If two threads of execution callÁ ü¸U8 5 `get_or_init` concurrently, one of them has to wait.Á ñU ú üõUM J Waiting fundamentally requires OS support. Execution environment needs toÁ üÃVP M understand who waits on whom to prevent deadlocks due to priority inversion.Á ü”WM J You _could_ make code to compile by blindly using pure spinlocks, but theÁ üâW+ ( runtime behavior would be subtly wrong.Á ŽX ú ü’XH E Given these constraints, `once_cell` provides the following options:Á ÛX ú üßXP M - The `race` module provides similar, but distinct synchronization primitiveÁ ü°YM J which is compatible with `no_std`. With `race`, the `f` function can beÁ üþYN K called multiple times by different threads, but only one thread will winÁ ÜÍZ to install the value.Á üéZN K - `critical-section` feature (with a `-`, not `_`) uses `critical_section`Á ä¸[ to implement blocking.Á Õ[ ú üÙ[! **Can I bring my own mutex?**Á û[ ú üÿ[O L There is [generic_once_cell](https://crates.io/crates/generic_once_cell) toÁ ¤Ï\ allow just that.Á ä\ ú üè\J G **Should I use `std::cell::OnceCell`, `once_cell`, or `lazy_static`?**Á ³] ú ü·]P M If you can use `std` version (your MSRV is at least 1.70, and you don't needÁ üˆ^P M extra features `once_cell` provides), use `std`. Otherwise, use `once_cell`.Á äÙ^ Don't use `lazy_static`.Á ö^ ú ¤ú^ # Related cratesÁ �_ ú ü“_L I * Most of this crate's functionality is available in `std` starting withÁ üà_E B Rust 1.70. See `std::cell::OnceCell` and `std::sync::OnceLock`.Á ü¦`K H * [double-checked-cell](https://github.com/niklasf/double-checked-cell)Á üò`5 2 * [lazy-init](https://crates.io/crates/lazy-init)Á ü¨a3 0 * [lazycell](https://crates.io/crates/lazycell)Á üÜa; 8 * [mitochondria](https://crates.io/crates/mitochondria)Á ü˜b9 6 * [lazy_static](https://crates.io/crates/lazy_static)Á üÒbA > * [async_once_cell](https://crates.io/crates/async_once_cell)Á ü”cL I * [generic_once_cell](https://crates.io/crates/generic_once_cell) (bringÁ ¬ác your own mutex)Á F¥…À’+ ¤¢+ ’+’+’+”¾d ¢+<Ûf »À|“f »ú¼¨f ̧f ü’f/ ü‰f: ßf ()*+,-.29;>þa$À á. �4TÆ î0
|
|||
|
|
RefUnwindSafeÁlß ¬½
|
|||
|
|
|
|||
|
|
UnwindSafeÁTî «½
|
|||
|
|
AtomicBoolÁTŽ ¬]
|
|||
|
|
AtomicPtrÁLš ¯] ®D¥ ¼À Š$½ ¦ ThreadÁ4à šI ®|®ãåÔÖü®.½¿£¥ü®]Ž�vxgiü®Œ]4´JLü÷0 ¥ Íìõ& ƒ � õ& $† Ììõ& $�½& &( ü«) ¥ ðÒ · �Ó$º½& üÙA ¥ ðÒ Þ ¬½õ& lá «½õ& Tñ½& ') üž . ¥ ðÒ £ ŸÔT¦ ½& œÑ ¥ ðÒ Ö ½& $%&' üë ( ÿ ½& ÍCüú
|
|||
|
|
7TŽ õ&½& ôD»Õüú +tˆ
|
|||
|
|
‘ ‘½& —
|
|||
|
|
|
|||
|
|
õ&$˜
|
|||
|
|
üÉkT× ’ ’½& ª)Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
¬M– — ! – " ! " è Íìª) â Íì�Ø å –"ª)¬M Ä› ª)¬M˜" Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
õ&�Ød§
|
|||
|
|
õ&ª)�Ø$é± ïª¬ ¦¨ … <closure_kind>Á # <closure_signature>Á # <upvars>Á # # #õ&ª)�Ø ¬M Á@ ¥3 ¼×ÌÂ$Ð “ “½& ¬M Õ
|
|||
|
|
$õ&$Öü°/lÅ ” ”½& ”õ& Ó
|
|||
|
|
%õ&$ÔüÔ 2<â • •½&ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ •õ& ê
|
|||
|
|
&õ&$ï üï +Tý ½&¥3
|
|||
|
|
'õ&$ˆ ¼ï!Tõ! ²9¤Ž"<”" ²9¬ª"D°" ²9üÇ"!tÍ" Ö2ü†# dŒ# Ö2¼°$T¶$ ²9l¬& 4³& Œ2 {ÏYhŸ‰Y /01äÀ&4À& . . á.á. a ã.»Ì- IÜž�B2®Û¼Ý¼Þ¼© ß¼ à¼ÛἈ cSñŸ«‡zÙšIšI ýÐ ›I¬‰ ¾"€sEæšú ¤â&Dâ& . . ¤]¤] V ¦]Á‚] üß3ø¤”& Œü&$ü& . . Ö2„È' ,Ï' ‹ 3 3 2 2 ÿ 4” 5 0|ö¾€˜Ö ‹ 0|ö¾€˜Ö 45 7Õ'äß',ß' 2 2 ‹ Þ4 ´�(L�( 2 2 Ö2¼œ( 8 – – '7 �" 7 ”º($½( — —'¬M 6 Â( 6
|
|||
|
|
7 8$Ç( ¸* 7¬Ù 8 ÄÙ 8 áÙ 8 8 7 8 ²9²9 ¬MüÓ.\”Ö. ˜ ™ ˜Þ4 ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ ™ “"¬M ˜"¬M ™¬M ð.
|
|||
|
|
9 ” ,é.€$ˆ/ µ2 9 ¬Ù : ÄÙ : áÙ : : 9 :úä¬Müû7?$þ7 š šÞ4 Ö2¬M Š8
|
|||
|
|
; ” ,ƒ8
|
|||
|
|
curr_queueÁT¢8 µ: ; ¬Ù < ÄÙ < áÙ < < ; <úä¬M ÷; ; ¬Ù = ÄÙ = áÙ = = ; =úä ²9 Tö@ 4ú@?ACü¥AG .\‡A $³A ëV²9 ¥ @ @ ðÒ,æA
|
|||
|
|
?õ&µ »A ¸A ü—DZ .\ùC L¥D ëV²9ëV ¥ B B ðÒ,ëD
|
|||
|
|
Aõ&µ ²Dø $¿D ¯D üðJl .\ÒJ DþJ ëV·
|
|||
|
|
ëV ¥ D ·
|
|||
|
|
E D E ÍìÏë ÜšK ðÒ,ÖK –"Ïëýä ´ŸK Ïëýä˜" ²9,°K
|
|||
|
|
Cõ&Ïëµ ŠK± —K ‡K `b t�g üåf* ' Single-threaded version of `OnceCell`.Á 4˜g S}a$Àg á. F I�4TÆg î0 F J× Ûg ` F Kí àg ë F Lr,óg é! F N DerefMutÁDúg ö! F OÞÏl•h ¬½ F QÿÏT¤h «½ F R$©g ¤©g ¨ª™›ŠŒ{}ü©gG rt[]ü©gi PR?A´Ém ü½hD A A cell which can be written to only once. It is not thread safe.Á †i ú üŽiC @ Unlike [`std::cell::RefCell`], a `OnceCell` provides simple `&`Á üÖi references to the contents.Á úi ú ü‚jR O [`std::cell::RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.htmlÁ Ùj ú láj
|
|||
|
|
# ExampleÁ <ój Ù\ üÿj$ Ý~ ¨k ú ü°k let cell = OnceCell::new();Á üÔk" assert!(cell.get().is_none());Á ûk ú üƒl. + let value: &String = cell.get_or_init(|| {Á ü¶l# "Hello, World!".to_string()Á <Þl Èu üêl' $ assert_eq!(value, "Hello, World!");Á ü–m" assert!(cell.get().is_some());Á <½m Ù\ DÔm ¥ T T ðÒ Ým î' phñ"<×q4 U ä™n ,™n F S S “5ü¡pA ¥ W W ðÒ ¦p �Ôl©p ŸÔT¹p î' üêp. ¥ Y Y ðÒ ïp ŸÔTòp î' ü¡q ¥ [ [ ðÒ ¦q î'\ ´ \ ¤Ëq <Îq î' Z Z
|
|||
|
|
\õ&ü�r. ¥ ^ ^ ðÒ ”r ¿cõ& T—r î'_ Àc _ ! üÈr4 Ër › œ � ›î' œ c c ˆ ¢cµ
|
|||
|
|
` £c bufÁ ` àB¤GS
|
|||
|
|
�Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
¬MŸÈŸÈ È ErrorÁ O˜éBL ] Ïr ]
|
|||
|
|
_õ&$Ðr ± Ör üÂt$ ¥ a a ðÒ Çt Øõ& ,Êt î'bc Ù Ú b c (* ôñt ,ôt ž žî' î' ` út `
|
|||
|
|
bõ&$ût ü¿v' TÂv Ÿ Ÿî' î' ¬M ` Ív `
|
|||
|
|
cõ&$Òv sourceÁ4Øv ü³x, ¥ e e ðÒ ¸x µßõ&õ& L»x î'f ·ß f $& üêx" íx ¡ ¢ ¡î' ¢î' d ðx d
|
|||
|
|
fõ&$ñx ¹
|
|||
|
|
,÷x ôÊy ¥ h h ðÒ Ïy ™õ& Òy î' üñy ¥ j j ðÒ öy î'k ë k Ì›z $žz õ&î' i i
|
|||
|
|
kõ&»,£z œôz ¥ m m ðÒ ùz î'nopqrstx{| ü¸{! ì’{ Creates a new empty cell.Á Å{ î' l l º?üÑ|0 ü¥|# Creates a new initialized cell.ÁTÞ| õ&î' l l
|
|||
|
|
oõ&»À üÙ~ üÔ}- * Gets a reference to the underlying value.Á Š~ ú ü–~( % Returns `None` if the cell is empty.Á à~ £ £î' ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ £õ& l ä~ l
|
|||
|
|
põ&$å~ üþ†+ üÐ�5 2 Gets a mutable reference to the underlying value.Á Ž‚ ú üš‚( ˜� Ë‚ ú üׂN K This method is allowed to violate the invariant of writing to a `OnceCell`Á ü®ƒI F at most once because it requires `&mut` access to `self`. As with allÁ ü€„F C interior mutability, `&mut` access permits arbitrary modification:Á Ï„ ú <Û„ Ù\ üë„$ Ý~ ˜… ú ü¤…2 / let mut cell: OnceCell<u32> = OnceCell::new();Á Ôß… cell.set(92).unwrap();Á ü‚†" *cell.get_mut().unwrap() = 93;Á ü†& # assert_eq!(cell.get(), Some(&93));Á <܆ Ù\<…‡ ¤ ¤î'ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ ¤õ& l �‡ l
|
|||
|
|
qõ&$’‡ ü¹Œ, ü¨ˆ. + Sets the contents of this cell to `value`.Á ߈ ú üëˆE B Returns `Ok(())` if the cell was empty and `Err(value)` if it wasÁ L¹‰ full.Á ˉ ú l׉ Üð <í‰ Ù\ üý‰$ Ý~ ªŠ ú ü¶Š ˜ñ üÞŠ" Áñ ‰‹ ú ü•‹% " assert_eq!(cell.set(92), Ok(()));Á üË& # assert_eq!(cell.set(62), Err(62));Á ò‹ ú üþ‹" ›ó <©Œ Ù\ ÀŒ ¥ ¥î' õ&Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
¬Mõ& l ÄŒ l
|
|||
|
|
rõ&$ÅŒ »,ËŒ üã‘9 ü„ŽR O Like [`set`](Self::set), but also returns a reference to the final cell value.Á ߎ ú lëŽ Üð <�� Ù\ ü‘�$ Ý~ ¾� ú üÊ� ˜ñ üò�" Áñ �� ú ü©�- * assert_eq!(cell.try_insert(92), Ok(&92));Á üß�4 1 assert_eq!(cell.try_insert(62), Err((&92, 62)));Á œ‘ ú ü¨‘" ›ó <Ó‘ Ù\Tê‘ ¦ ¦î' õ&Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
¦õ& ¯’õ& l õ‘ l
|
|||
|
|
sõ&$ö‘ »,ü‘ ü‹œT ü¯–; 8 Gets the contents of the cell, initializing it with `f`Á Ôó– if the cell was empty.Á –— ú d¢— # PanicsÁ ·— ú ü×F C If `f` panics, the panic is propagated to the caller, and the cellÁ Ô’˜ remains uninitialized.Á µ˜ ú üÁ˜E B It is an error to reentrantly initialize the cell from `f`. DoingÁ Ô�™ so results in a panic.Á ²™ ú l¾™ Üð <Ô™ Ù\ üä™$ Ý~ ‘š ú ü�š ˜ñ üÅš( % let value = cell.get_or_init(|| 92);Á Üöš assert_eq!(value, &92);Á üš›4 1 let value = cell.get_or_init(|| unreachable!());Á Ü×› •– <û› Ù\\’œ § §î' ª) §õ& l— u u ¡œ l ÀØ žœ áØlÑœ ª)¬M˜" õ& Ýœ
|
|||
|
|
tõ&ª)$¢œ ± ¨œ >@ Löœ $ûœ F v žÍúÅ,ø žÍúÅ,ø ª� t¬Ù w ÄÙ w áÙ w w t wõ&ª) ¬MÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
õ&Ë™ ª)üÎ¥q ü°ž> ; Gets the contents of the cell, initializing it with `f` ifÁ ü÷ž@ = the cell was empty. If the cell was empty and `f` failed, anÁ ´ÀŸ error is returned.Á ߟ ú dëŸ ÷’ € ú üŒ F ›“ ÔÛ ë“ þ ú üŠ¡E �” ÔØ¡ ì” û¡ ú l‡¢ Üð
|
|||
|
|
` £cÍ÷ ` àB¤GS
|
|||
|
|
¬ôø … âÀ …
|
|||
|
|
ˆõ&ª)$ãÀ ± éÀ ¬‚ ¥ Š — ‹ Š ‹ ðÒ ‡Â ÀØ ŠÂ ñ(Œ� üÇÅ' ü¢ÂB ? Creates a new lazy value with the given initializing function.Á í ú lù Üð <�à Ù\ ŒŸÃ # fn main() {Á ü¹Ã z âà ú üîÃ, ) let hello = "Hello, World!".to_string();Á £Ä ú ü¯Ä2 / let lazy = Lazy::new(|| hello.to_uppercase());Á êÄ ú üöÄ( % assert_eq!(&*lazy, "HELLO, WORLD!");Á <§Å Òk <·Å Ù\ ÔÅ ª)ñ( ‰ ‰
|
|||
|
|
Œõ&ª)€¸ üæÇ3 üÌÆ4 1 Consumes this `Lazy` returning the stored value.Á ‰Ç ú ü•ÇH E Returns `Ok(value)` if `Lazy` is initialized and `Err(f)` otherwise.ÁTíÇ ñ(Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
õ&ª) ‰ ‰
|
|||
|
|
�õ&ª) thisÁ$øÇ ‰É �¬Ù Ž ÄÙ Ž áÙ Ž Ž � Žõ&ª) ¬Mª) ÇB ¹É �¬Ù � ÄÙ � áÙ � � � �õ&ª)�¾¬Mü–Ê$ ¥ ‘ — ’ ‘ ’ ù˜ Ê ÀØ žÊ áØl¡Ê ðÒ ›Ê ñ(“•—˜ 35 ü€Î% üÅÊG D Forces the evaluation of this lazy value and returns a reference toÁ |•Ë the result.Á Ë ú ü¹Ë< 9 This is equivalent to the `Deref` impl, but is explicit.Á þË ú lŠÌ Üð < Ì Ù\ ü°Ì z ÙÌ ú üåÌ let lazy = Lazy::new(|| 92);Á ŽÍ ú üšÍ( % assert_eq!(Lazy::force(&lazy), &92);Á äËÍ assert_eq!(&*lazy, &92);Á <ðÍ Ù\,‡Î ñ( õ& � “Î �
|
|||
|
|
“õ&ª)¥¼$�Î ÊÎ “¬Ù ” ÄÙ ” áÙ ” ” “ ”õ&ª) ¬Mõ& ñ( üÆÓ1 üöÏO L Forces the evaluation of this lazy value and returns a mutable reference toÁ |ÎÐ à¿ æÐ ú üòÐ? < This is equivalent to the `DerefMut` impl, but is explicit.Á ºÑ ú lÆÑ Üð <ÜÑ Ù\ üìÑ z •Ò ú ü¡Ò$ ! let mut lazy = Lazy::new(|| 92);Á ÎÒ ú üÚÒ0 - assert_eq!(Lazy::force_mut(&mut lazy), &92);Á Ô“Ó assert_eq!(*lazy, 92);Á <¶Ó Ù\LÍÓ ® ®ñ( ®õ& � ÝÓ �
|
|||
|
|
•õ&ª)¥¼$×Ó çÖ •¬Ù – ÄÙ – áÙ – – • –õ&ª) ¬M õ& ¬MüÀÚ+ ü�×: 7 Gets the reference to the result of this lazy value ifÁ üÐ×1 . it was initialized, otherwise returns `None`.Á ŠØ ú l–Ø Üð <¬Ø Ù\ ü¼Ø z åØ ú üñØ ‘Á šÙ ú ü¦Ù' $ assert_eq!(Lazy::get(&lazy), None);Á äÖÙ ûÁ üûÙ, ) assert_eq!(Lazy::get(&lazy), Some(&92));Á <°Ú Ù\ ÇÚ ¯ ¯ñ( ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ ¯õ& � ÑÚ �
|
|||
|
|
—õ&ª)¥¼$ËÚ üîÞ7 ü�ÛB ? Gets the mutable reference to the result of this lazy value ifÁ üèÛ1 ÐÉ ¢Ü ú l®Ü Üð <ÄÜ Ù\ üÔÜ z ýÜ ú ü‰Ý$ ‹Æ ¶Ý ú üÂÝ/ , assert_eq!(Lazy::get_mut(&mut lazy), None);Á ÔúÝ �Ç ü�Þ8 5 assert_eq!(Lazy::get_mut(&mut lazy), Some(&mut 92));Á <ÞÞ Ù\<õÞ ° °ñ(ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ °õ& � ƒß �
|
|||
|
|
˜õ&ª)¥¼$ýÞ üÝß. ¥ š — › › š ù˜ ôß ÀØ åß áØlèß ðÒ âß ñ(œ� ê! ë! � 9; \–à 4›à ™ ™ õ&¬¯à ,²à ± ±ñ( ±õ& ™ ¸à ™
|
|||
|
|
�õ&ª)$¹à üúà1 ¥ Ÿ — Ÿ ù˜ ‘á ÀØ ‚á áØl…á ðÒ ÿà ñ(¡ ÷! ¡ 24 ü¶á! L¹á ² ²ñ( ²õ& ž
|
|||
|
|
M3® ° ² ½&ž* ;+O ¥ ½&ž* ¯ ¯
|
|||
|
|
°õ&gi 4¿î ¥ ¯ ¯ ½&üÍî ¥ ´ ´ ðÒ Òî ž*µ ´ µ Ü÷î <úî ž* ³ ³
|
|||
|
|
µõ&üÆï. ¥ · · ðÒ Ëï Ã÷TÎï ž*¸ Àc ¸ üÿï4 ‚ð ³ ´ µ ³ž* ´ c c ˆ ¢cµ
|
|||
|
|
` £cÍ÷ ` àB¤GS
|
|||
|
|
µôø ¶ †ð ¶
|
|||
|
|
¸õ&$‡ð ± �ð üùñ$ ¥ º º ðÒ þñ Àú,�ò ž*»¼ Ù Ú » ¼ ') ô¨ò ,«ò ¶ ¶ž* ž* ¹ ±ò ¹
|
|||
|
|
»õ&$²ò üîó' Tñó · ¸ ·ž* ¸ž* ¬M ¹ üó ¹
|
|||
|
|
¼õ&$�ô ªû4‡ô üâõ ¥ ¾ ¾ ðÒ çõ ž*¿ ë ¿ ÌŒö $�ö õ&ž* ½ ½
|
|||
|
|
¿õ&»,”ö üáö, ¥ Á Á ðÒ æö ÛüLéö ž* ·ß  ü˜÷) ›÷ ¹ º ¹ž* ºž* À ž÷ À
|
|||
|
|
Âõ&$Ÿ÷ ¹
|
|||
|
|
,¥÷ ôÿ÷ ¥ Ä Ä ðÒ „ø —þ‡ø ž* œ¦ø ¥ Æ Æ ðÒ «ø ž*ÇÈÉÊËÌÍÎÐÔ×Ø ,. üêø! ìÄø ‰ÿ ÷ø ž* Å Å áFüîù0 üÂù# åÿTûù õ&ž* Å Å
|
|||
|
|
Èõ&»m"ü’ü üáú/ , Gets the reference to the underlying value.Á ™û ú ü¥ûC @ Returns `None` if the cell is empty, or being initialized. ThisÁ Äñû method never blocks.Á ™ü » »ž* ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ »õ& Å �ü Å
|
|||
|
|
Éõ&$žü Ħ„ ü�þD A Gets the reference to the underlying value, blocking the currentÁ ÜÝþ thread until it is set.Á �ÿ ú <�ÿ Ù\ ü�ÿ" µe Èÿ ú üÔÿ8 5 let mut cell = std::sync::Arc::new(OnceCell::new());Á ü•€ let t = std::thread::spawn({Á ü¾€0 - let cell = std::sync::Arc::clone(&cell);Á ü÷€% " move || cell.set(92).unwrap()Á <¥� Èu µ� ú üÁ�2 / // Returns immediately, but might return None.Á üü�$ ! let _value_or_none = cell.get();Á ©‚ ú üµ‚J G // Will return 92, but might block until the other thread does `.set`.Á üˆƒ" let value: &u32 = cell.wait();Á ܳƒ assert_eq!(*value, 92);Á ´×ƒ t.join().unwrap();Á <öƒ Ù\ »À|Œ„ ¼†„ $„ ¼ ¼ž* ¼õ& Å ²„ Å
|
|||
|
|
Êõ&$³„ üó‹+ üû†7 4 Gets the mutable reference to the underlying value.Á »‡ ú üLJ( ˜� ø‡ ú ü„ˆN ؃ üÛˆI ±„ ü‰F …… ü‰ ú <ˆŠ Ù\ ü˜Š" µe Ê ú üÏŠ2 ‹† ÔŠ‹ dž Ü‹ ø§ <Ñ‹ Ù\<ú‹ ½ ½ž*ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ ½õ& Å ‚Œ Å
|
|||
|
|
Ëõ&$‡Œ ü—�( üÑŒF C Get the reference to the underlying value, without checking if theÁ Ä � cell is initialized.Á Á� ú dÍ� # SafetyÁ â� ú üî�F C Caller must ensure that the cell is in initialized state, and thatÁ ü½Ž? < the contents are acquired by (synchronized to) this thread.Ál¥� ¾ ¾ž* ¾õ& Å ³� Å
|
|||
|
|
Ìõ&$´� ü»•, üø�. þˆ ¯� ú ü»�E ĉ L‰‘ “Š ›‘ ú l§‘ Ü𠽑 ú <É‘ Ù\ üÙ‘" µe „’ ú ü�’1 . static CELL: OnceCell<i32> = OnceCell::new();Á Ê’ ú |Ö’ �j üî’& # assert!(CELL.get().is_none());Á �“ ú ü©“ std::thread::spawn(|| {Á üÑ“- * assert_eq!(CELL.set(92), Ok(()));Á ܇” }).join().unwrap();Á «” ú ü·”* ' assert_eq!(CELL.set(62), Err(62));Á üê”* ' assert_eq!(CELL.get(), Some(&92));Á ,�• Ë\ <«• Ù\ • ¿ ¿ž* õ&Â� Å Æ• Å
|
|||
|
|
Íõ&$Ç• »,Í• üïš9 ü†—R Ó� á— ú lí— Ü𠃘 ú <�˜ Ù\ üŸ˜" µe ʘ ú üÖ˜ ˜ñ üþ˜" Áñ ©™ ú üµ™- ž� üë™4 Ö� ¨š ú ü´š" ›ó <ßš Ù\Töš À Àž* õ&Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
Àõ& —‡õ& Å �› Å
|
|||
|
|
Îõ&$‚› »,ˆ› û› Î¬Ù Ï ÄÙ Ï áÙ Ï Ï Î Ïõ&åÄ ¥3ü¾¥T ü¹�G D Gets the contents of the cell, initializing it with `f` if the cellÁ t‰ž was empty.Á ž ú ü¬žC @ Many threads may call `get_or_init` concurrently with differentÁ üøžG D initializing functions, but it is guaranteed that only one functionÁ ¬ÈŸ will be executed.Á æŸ ú dòŸ ÷’ ‡ ú ü“ F ›“ Ôâ ë“ …¡ ú ü‘¡C @ It is an error to reentrantly initialize the cell from `f`. TheÁ üÝ¡G D exact outcome is unspecified. Current impl
|
|||
|
|
` £cÍ÷ ` àB¤GS
|
|||
|
|
Æôø Þ ÃÊ Þ
|
|||
|
|
áõ&ª)$ÄÊ ± ÊÊ üéÍC ¥ ã — ä ã ä ðÒ õÍ ÀØ øÍ Ììª) $ûÍ � ž* $¨Î “+ 24 68 üÜÎW ¥ æ — ç æ ç ðÒ áÎ ÀØ äΠͳlçÎ ¬½ž* l¦Ï “+ +- /1 ¬¼Ï ¥ é — ê é ê ðÒ ÁÏ ÀØ ÄÏ “+ëì ü³Ð$ üÜÏ8 5 Creates a new lazy value with the given initializingÁ l�Ð
|
|||
|
|
function.Á ÀÐ ª)“+ è è
|
|||
|
|
ëõ&ª)±$üÌÒ3 ü²Ñ4 ‚º ïÑ ú üûÑH κTÓÒ “+´¼ è è
|
|||
|
|
ìõ&ª)¥¼$ÞÒ ïÓ ì¬Ù í ÄÙ í áÙ í í ì íõ&ª)�¾˜¾ŸÔ ì¬Ù î ÄÙ î áÙ î î ì îõ&ª)�¾¬MüüÔ$ ¥ ð — ñ ñ ð ù˜ “Õ ÀØ „Õ áØl‡Õ ðÒ �Õ “+òôö÷ 35 üØØ% ü«Õ0 - Forces the evaluation of this lazy value andÁ üäÕ9 6 returns a reference to the result. This is equivalentÁ ü¦Ö) & to the `Deref` impl, but is explicit.Á ØÖ ú läÖ Üð <úÖ Ù\ ôŠ× �s ±× ú ü½× ‘Á æ× ú üò×( ÉÁ ä£Ø ûÁ <ÈØ Ù\,ßØ Ç Ç“+ Çõ& ï ëØ ï
|
|||
|
|
òõ&ª)¥¼$åØ ¢Ù ò¬Ù ó ÄÙ ó áÙ ó ó ò óõ&ª)åÄ “+ üîÝ1 üÎÚ0 »° ü‡ÛA > returns a mutable reference to the result. This is equivalentÁ üÑÛ) º± ƒÜ ú l�Ü Üð <¥Ü Ù\ ôµÜ �s ÜÜ ú üèÜ$ ‹Æ •Ý ú ü¡Ý4 1 assert_eq!(Lazy::force_mut(&mut lazy), &mut 92);Á <ÞÝ Ù\LõÝ È È“+ Èõ& ï …Þ ï
|
|||
|
|
ôõ&ª)¥¼$ÿÝ �á ô¬Ù õ ÄÙ õ áÙ õ õ ô õõ&ª)éɬMüæä+ üµá: ‹É üøá1 ÐÉ ²â ú l¾â Üð <Ôâ Ù\ ôäâ �s ‹ã ú ü—ã ‘Á Àã ú üÌã' ëÊ äüã ûÁ ü¡ä, «Ë <Öä Ù\ íä É É“+ ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ Éõ& ï ÷ä ï
|
|||
|
|
öõ&ª)¥¼$ñä üŒé7 üÃå: ‹É ü†æ1 ÐÉ Àæ ú lÌæ Üð <âæ Ù\ ôòæ �s ™ç ú ü¥ç$ ‹Æ Òç ú üÞç/ ÚÎ ä–è ûÁ ü»è8 ¢Ï <üè Ù\<“é Ê Ê“+ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ Êõ& ï ¡é ï
|
|||
|
|
÷õ&ª)¥¼$›é üûé. ¥ ù — ú ú ù ù˜ ’ê ÀØ ƒê áØl†ê ðÒ €ê “+ûü ê! ë! ü 9; \´ê 4¹ê ø ø õ&¬Íê ,Ðê Ë Ë“+ Ëõ& ø Öê ø
|
|||
|
|
üõ&ª)$×ê ü˜ë1 ¥ þ — ÿ þ ÿ ù˜ ¯ë ÀØ ë áØl£ë ðÒ �ë “+€ ÷! € 24 üÔë! L×ë Ì Ì“+ Ìõ& ý áë ý
|
|||
|
|
€õ&ª)$æë ü¯ì$ ¥ ‚ ‚ ðÒ ´ì Ö<·ì ƒ,ƒ ´ ƒ ¼±í üÞìJ ÛÕ<´í ƒ, � �
|
|||
|
|
ƒõ&\¡ñ 4¤ñ ¥ ¬M
|
|||
|
|
„ dÌñ ü E B Thread-safe, non-blocking, "first one wins" flavor of `OnceCell`.Á Fú üJI F If two threads race to initialize a type from the `race` module, theyÁ ü”J G don't block, execute initialization function together, but only one ofÁ Üß them stores the result.Á ûú üÿ/ , This module does not require `std` feature.Á ¯ú ´³ # Atomic orderingsÁ Êú üÎ8 5 All types in this module use `Acquire` and `Release`Á ü‡L I [atomic orderings](Ordering) for all their operations. While this is notÁ üÔP M strictly necessary for types other than `OnceBox`, it is useful for users asÁ ü¥M J it allows them to be certain that after `get` or `get_or_init` returns onÁ üóJ G one thread, any side-effects caused by the setter thread prior to themÁ ü¾O L calling `set` or `get_or_init` will be made visible to that thread; withoutÁ üŽO L it, it's possible for it to appear as if they haven't happened yet from theÁ üÞM J getter thread's perspective. This is an acceptable tradeoff to make sinceÁ ü¬I F `Acquire` and `Release` have very little perform
|
|||
|
|
some `f`.Á\ó% Ñ ÑÊ, —£Ò � — ˜ ˜ ‚& � ÍìöÚ ÿ% –"öÚ¬M Ä´& öÚ¬M˜" £ÒdÀ&
|
|||
|
|
—öÚ$ƒ&± ‰&EG LÜ& $á&… ™ â6‹X¹ â6‹X¹ Œ' —¬Ù š ÄÙ š áÙ š š — šöÚ ¬MÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
£Ò–Ü öÚüç*~ ü‰(>·š üÌ(@€› ´‘)Ê› ¬)ú ü´)L”Ø ü…*KêØ lÕ*¾Ù|î* Ò ÒÊ, öÚÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
£Ò– � — œ – � � œ „+ � £Û þ* ÍìÜß �+ ´ÛüÁ+# öÚ¬M˜" Šß¼Í+
|
|||
|
|
›öÚÜß$…+± ‹+PR LN üÿ,Y$‚- … Ó ÓÊ, ‘Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
£Ò – � – Ÿ ‘ Ÿ Š- � Íì�â ‡- Íì¶á ü”-( –"¶á¬M ü™-# ¶á¬M˜" »á¼¥-
|
|||
|
|
ž�â¶á$‹-± ‘-\^ XZ üÂ/E„Å/ … Ô ÔÊ, £ÒÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
²9²9 � Ö/ �
|
|||
|
|
¡ $×/¹ Ý/lõ1 ‰-£¤¥¦©® Ô¹2 ì‰2‰ÿ Æ2 ‰- ¢ ¢
|
|||
|
|
£ üÂ3! ô‘3–Ð É3 Õ Õ‰- ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ ¢ Í3 ¢
|
|||
|
|
¤ $Î3ü¾50 ü 4.þˆ Ó4ú üÛ4B˜Õ L¢5“Š Å5 Ö Ö‰- ”× ¢ É5 ¢
|
|||
|
|
¥ $Ê5»,Ð5üÄ8Q üª6K × Tú6ô× ‰7ú ü‘7L”Ø üâ7KêØ l²8¾Ù\Ë8 × ×‰- öÚ ¢ — § § Ú8 ¢ £Û ×8 ´Û„„9 öÚ¬M˜" $�9
|
|||
|
|
¦öÚ$Û8± á88: Ì9 ¦¬Ù ¨ ÄÙ ¨ áÙ ¨ ¨ ¦ ¨öÚ ¬M£Ò òÝüÎ<n üð9>·š ü³:@€› ´ø:Ê› “;ú ü›;L”Ø üì;KêØ l¼<¾Ù|Õ< Ø Ø‰- öÚÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
Üß ¢ — ª – « ª « ë< ¢ £Û å< �à è< ´ÛÜ = öÚ¬M˜" ˆì|¬=
|
|||
|
|
©öÚÜß$ì<± ò<FH KM æ= ©¬Ù ¬ ÄÙ ¬ áÙ ¬ ¬ © ¬öÚÜß ¬MŠß òÝü±>*T´> … £Ò ¢ ¢
|
|||
|
|
»,¿>ü�?(D“? … £Ò ¢ ¢
|
|||
|
|
® »,œ?ÌÈ@ üŽ@9³Ù <Ó@ ‹ ° ¥ ± ° ± Íìˆ. ß@ ˆ. ‹ ü�A%È- ÿŠZa.pI� ²³Û@46 œè@,è@… ¯ ¯ «RN,�A… ¯ ¯ • • – øQ Fu\»Ÿî0î0 �4 ð0»Ì- ·}—KEüC£ ‹ ˆ. üëA0 ‹ µ ¥ ¶ µ ¶ ¥ð ûA � ˆ. $þAÈ- ÷A ü B/ ‹ ¸ ¥ ¹ ¸ ¹ ¥ð ©BÈ-º Àc º ¥B üÖBD ÙB Ù Ú Û ÙÈ- Ú c c ˆ ¢cµ
|
|||
|
|
` £cÍ÷ ` àB¤GS
|
|||
|
|
Ûôø · ÝB ·
|
|||
|
|
º ‹ ˆ.$ÞB± äBüÕC& ‹ ¼ ¥ ½ ¼ ½ ¥ð ÞCÈ-¾ ´ ¾ ÚC ¤‚D<…D È- » »
|
|||
|
|
¾ ‹ ˆ.Ô¶D ‹ À ¥ Á À Á ¥ð ¿DÈ-ÂÃÄÅÉÌÏÑ »D%' ÔùD ì×D‰ÿ †E È- ¿ ¿
|