325 lines
175 KiB
Plaintext
325 lines
175 KiB
Plaintext
|
rust
|
|||
|
|
eº #rustc 1.93.0 (254b59607 2026-01-19)Á³VOÐêùÿ²?ÑL¼�§Ì± -a7a40eb546f9e2b0Á stable_deref_traitÁþÖ›#Ÿžõ E4Õèr -80e318edb62c0e9cÁ ë&Gf·Ã ¬ëñq:¤»b -bb76018b1173caf6Á yoke_deriveÁÙ@’÷ò +çšFåc�z -5e7d4687001d5481Á zerofromÁˆo“ÄÄx(ÃjBsÖ ›ªÅ -e7a4aaab09db7e3aÁ zerofrom_deriveÁ¿ &èéXЕ)ˆ ç -03b1dd1f2d87713aÁ ‰ á,Ê ¶<© á<³ Œ© BoxÁ Ķ<žá<¨Œžôò¶<Ïá<ÙŒÏI ¡¶<üá<†Œüq$Ãà$¬ testsÁ,˜aà$�a erasedÁ4š ¶<þ á<ˆ Œþ ƒ
|
|||
|
|
ErasedArcCartÁl߶<·á<ÁŒ·ƒ
|
|||
|
|
ErasedBoxCartÁlî¶,á*(*ƒ ErasedRcCartÁdý¶QáOMOƒ€ ï¶<Éá<ӌɃô�¶<úá<„ŒúƒI ̶<§á<±Œ§¼€ ù¶<Ñá<یѼœ<þ¶ á ³ cartable_ptrÁ sentinel_forÁ ™ SENTINELÁ privateÁ SealedÁ CartablePointerLikeÁ RawÁ into_rawÁ drop_rawÁ CloneableCartablePointerLikeÁ
|
|||
|
|
addref_rawÁ 'aÁ ™ ® ™ Î Ø ç ® ™ ™ !k !¾ !
|
|||
|
|
from_cartableÁ ! is_noneÁ &k &² )k )È ,k .k 0k eitherÁ 2 222 6 C0Á 6 C1Á 6™ 6š 6‚ ; 2=Ž
|
|||
|
|
=—
|
|||
|
|
=™ 2AŽ
|
|||
|
|
A—
|
|||
|
|
kinda_sorta_danglingÁ D DDDDDD KindaSortaDanglingÁ K™ K dangleÁ D N™ N• N
|
|||
|
|
into_innerÁ DR™ Rš R‚ DV™ V„ DY™ Y² macro_implsÁ \ \\\\\\ copy_yoke_implÁ \ impl_copy_typeÁ \ unsafe_complex_yoke_implÁ \ f® f™ f 'bÁ fØ \k® k T1Á k©
|
|||
|
|
k T2Á k©
|
|||
|
|
kØ \r® r™ r©
|
|||
|
|
rÍ r rØ x utilsÁ z zz transform_mut_yokeableÁ }® } YÁ } FÁ } RÁ }©
|
|||
|
|
yokeÁ ƒ ƒƒƒƒƒƒƒƒƒ ƒ YokeÁ ŽÒ Ž® Žk Ž yokeableÁ Ž cartÁ ƒ ”Ò ”® ”k ”®”Í ƒšÒ š® šk š attach_to_cartÁ žÚ ž 'deÁ š try_attach_to_cartÁ ¡ EÁ ¡Ú ¡Ô š attach_to_cart_badlyÁ ¥Ô š try_attach_to_cart_badlyÁ §ù §Ô ƒªÒ ª® ªk ª getÁ ®® ª backing_cartÁ ª into_backing_cartÁ ª replace_cartÁ ² C2Á ² impl FnOnce(C) -> C2Á ª with_mutÁ µ® µÚ µ©
|
|||
|
|
ª with_mut_returnÁ ¹® ¹Ú ¹â ¹©
|
|||
|
|
ª wrap_cart_in_optionÁ ƒ¿Ò ¿® ¿ new_always_ownedÁ ¿
|
|||
|
|
into_yokeableÁ ƒÄÒ Ä® Äk Ä new_ownedÁ Ä try_into_yokeableÁ ƒÊÒ Ê® Êk Ê convert_cart_into_option_pointerÁ ƒÏÒ Ï® Ïk Ïå ƒ
|
|||
|
|
CloneableCartÁ ƒÕ™ ƒ×® ×™ ƒ ƒ
|
|||
|
|
ÛÒ Û® Ûk Û®ÛÈ ƒ áÒ á® ák á map_projectÁ å PÁ åÚ å® å®á map_project_clonedÁ ê 'thisÁ êý êÚ ê® ê®á try_map_projectÁ ðý ðÚ ðù ð® ð®á try_map_project_clonedÁ ö¸ öý öÚ öù ö® ö®á !map_project_with_explicit_captureÁ ýý ý™ ý® ý®á (map_project_cloned_with_explicit_captureÁ ‚¸ ‚ý ‚™ ‚® ‚®á %try_map_project_with_explicit_captureÁ ˆý ˆ™ ˆù ˆ® ˆ®á ,try_map_project_cloned_with_explicit_captureÁ Ž¸ Žý Ž™ Žù Ž® Ž®ƒ •Ò •® •k •
|
|||
|
|
map_with_cartÁ ™ý ™Ú ™® ™®• map_with_cart_clonedÁ ž¸ žý žÚ ž® ž®• try_map_with_cartÁ ¤ý ¤Ú ¤ù ¤® ¤®• try_map_with_cart_clonedÁ ª¸ ªý ªÚ ªù ª® ª®ƒ
|
|||
|
|
±Ò ±® ±k ± wrap_cart_in_either_aÁ µ BÁ ± wrap_cart_in_either_bÁ · AÁ ƒ ƒƒ Ò ¼ ¼¼¼ YokeableÁ À® ÀØ À transformÁ À transform_ownedÁ À makeÁ À
|
|||
|
|
transform_mutÁ ÆÚ Æ©
|
|||
|
|
¼ É® É™ ÉØ É¥ ɶ ÉÍ ÉÙ ÐÚ Ð©
|
|||
|
|
¼Ó® Ó™ ÓØ Ó¥ Ó¶ ÓÍ ÓÙ ÚÚ Ú©
|
|||
|
|
zero_fromÁ Ý ÝÝÝÝÝ ãÒ ãk ã® ã®ã attach_to_zero_copy_cartÁ è CartableOptionPointerÁ ðk ð innerÁ ð _cartableÁ ôk ôÍ 2
|
|||
|
|
EitherCartÁ ÷Ž
|
|||
|
|
÷—
|
|||
|
|
÷Ñ ú
|
|||
|
|
úì ÷« ý
|
|||
|
|
ýì 2€Ž
|
|||
|
|
€—
|
|||
|
|
€È 2„Ž
|
|||
|
|
„—
|
|||
|
|
2‡Ž
|
|||
|
|
‡—
|
|||
|
|
‡Õ 2‹Ž
|
|||
|
|
‹—
|
|||
|
|
‹˜ 2�Ž
|
|||
|
|
�—
|
|||
|
|
�Í \“® “Ø “¥ “¶ “Í “Ù ™Ú ™©
|
|||
|
|
\œ® œØ œ¥ œ¶ œÍ œÙ ¢Ú ¢©
|
|||
|
|
\¥® ¥Ø ¥¥ ¥¶ ¥Í ¥Ù «Ú «©
|
|||
|
|
\®® ®Ø ®¥ ®¶ ®Í ®Ù ´Ú ´©
|
|||
|
|
\·® ·Ø ·¥ ·¶ ·Í ·Ù ½Ú ½©
|
|||
|
|
\À® ÀØ À¥ À¶ ÀÍ ÀÙ ÆÚ Æ©
|
|||
|
|
\ É® ÉØ É¥ ɶ ÉÍ ÉÙ ÏÚ Ï©
|
|||
|
|
\
|
|||
|
|
Ò® ÒØ Ò¥ Ò¶ ÒÍ ÒÙ ØÚ Ø©
|
|||
|
|
\ Û® ÛØ Û¥ Û¶ ÛÍ ÛÙ áÚ á©
|
|||
|
|
\ ä® äØ ä¥ ä¶ äÍ äÙ êÚ ê©
|
|||
|
|
\
|
|||
|
|
í® íØ í¥ í¶ íÍ íÙ óÚ ó©
|
|||
|
|
\ö® öØ ö¥ ö¶ öÍ öÙ üÚ ü©
|
|||
|
|
\ÿ® ÿØ ÿ¥ ÿ¶ ÿÍ ÿÙ …Ú …©
|
|||
|
|
\ˆ® ˆØ ˆ¥ ˆ¶ ˆÍ ˆÙ ŽÚ Ž©
|
|||
|
|
\‘® ‘Ø ‘¥ ‘¶ ‘Í ‘Ù —Ú —©
|
|||
|
|
f¥ f¶ fÍ fÙ �Ú �©
|
|||
|
|
k¥ k¶ kÍ kÙ £Ú £©
|
|||
|
|
r¥ r¶ rÍ rÙ ©Ú ©©
|
|||
|
|
%
|
|||
|
|
(
|
|||
|
|
+
|
|||
|
|
;
|
|||
|
|
U
|
|||
|
|
X
|
|||
|
|
[
|
|||
|
|
™
|
|||
|
|
™
|
|||
|
|
™
|
|||
|
|
°
|
|||
|
|
à
|
|||
|
|
ö
|
|||
|
|
ö
|
|||
|
|
ö
|
|||
|
|
ƒ
|
|||
|
|
Š
|
|||
|
|
Š
|
|||
|
|
Ž
|
|||
|
|
’
|
|||
|
|
’
|
|||
|
|
’
|
|||
|
|
–
|
|||
|
|
Ÿ
|
|||
|
|
¨
|
|||
|
|
±
|
|||
|
|
º
|
|||
|
|
Ã
|
|||
|
|
Ì
|
|||
|
|
Õ
|
|||
|
|
Þ
|
|||
|
|
ç
|
|||
|
|
ð
|
|||
|
|
ù
|
|||
|
|
‚
|
|||
|
|
‹
|
|||
|
|
”
|
|||
|
|
ÔÀ ®™ ý/ ý/ à` ð ð ¡" òÅ" óÒ" ¶ ÓdÑåÙ k � £0 Þ£0 Ô£0 ¨â£0 „ £0 Þ ÷ ú ûÑ üì ý þ« ÿì Q£^Ÿ
|
|||
|
|
á Ž
|
|||
|
|
—
|
|||
|
|
¬â™1 ž™1™1 £™1 à`™1 ì ™1 ™1 Ô™1 ì K K — M· D ’yHG| ÿC ™ ù ¼2 � ¼2 À ® À ® À ® À ® À ® À ® À ® À ® À ® À ® À ® À ® À ® À ® À ® Àø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE>ƒ0 ® ÀÄ
|
|||
|
|
Ô
|
|||
|
|
® Àƒ0 Í ® à` Ž Ž ¯ ’Ò ƒ “â ƒ 9+¼%+}A Òk Ôø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE>å2 Ôý/ Ô†3 Þø5 À ƒ0 ® À‰ ‰ Š PhantomDataÁ Ñ{ ·Ë…YÚƒ0 ®
|
|||
|
|
|
|||
|
|
|
|||
|
|
ô ð� ÷” Ž& ðY K) ð€ ÷Û Ž, ðA ÷Õø°×
|
|||
|
|
Ú
|
|||
|
|
. ð0 ð„ ÷‡ ÷‹ ÷6 ÷R K= ÷V K“
|
|||
|
|
œ¥®·ÀÉ ÒÛäíöÿ ˆ‘ fø°k
|
|||
|
|
rÉ
|
|||
|
|
Ó‰ ø à`� Þ Ô¨â „ ¬âž£ì ù ÀÄ� 4¡
|
|||
|
|
" „�
|
|||
|
|
�å2 3 D § üçL
|
|||
|
|
K å2 ² ¹ ü²‡ P ¼2 $Ø å2 4Ê �Ò�Ò MaybeUninitÁ �Ò uninitÁü �Ò˜ü gÇ@ÇeÉRå2 ù å2 ø · h — ü¬±! Dı
|
|||
|
|
% ¼¬±
|
|||
|
|
P±6 4 G ̱ $á±
|
|||
|
|
ø° ·6 ü½°³
|
|||
|
|
Ž ±6ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE>·6 ï± ö± ü‡°ï È Ž Ž ¯ ’Ò ƒ “â ƒ 9+¼%+}A±6ï= $®° ±6 Dž° K K — M· D ’yHG| ÿC±6 ‹ ±6 ‰ ï= G ÒN ¼ ìï
|
|||
|
|
ŒÞï ¹ †3 çï & ()Á ݤ
|
|||
|
|
ŒÏ¤ º †3 ؤ & ()Á Áò
|
|||
|
|
Œ³ò » †3 ¼ò & ()Á ¾
|
|||
|
|
÷ à1æ1 û + ™1 6 à1 = D É
|
|||
|
|
÷à1æ1 þ + ™1 6 æ1 = D 2D\zƒ¼Ý³ … DÍ À î… ( êælî Ô ì¯$ý Ž í ZeroFromÁDÓ
|
|||
|
|
ï†C 5 ïüË‘ üËj g This crate provides [`Yoke<Y, C>`][Yoke], which allows one to "yoke" (attach) a zero-copy deserializedÁ ü¶‡ „ object (say, a [`Cow<'a, str>`](alloc::borrow::Cow)) to the source it was deserialized from, (say, an [`Rc<[u8]>`](alloc::rc::Rc)),Á ü¾i f known in this crate as a "cart", producing a type that looks like `Yoke<Cow<'static, str>, Rc<[u8]>>`Á ü¨* ' and can be moved around with impunity.Á Ó Ë ü×f c Succinctly, this allows one to "erase" static lifetimes and turn them into dynamic ones, similarlyÁ ü¾T Q to how `dyn` allows one to "erase" static types and turn them into dynamic ones.Á “ Ë ü—X U Most of the time the yokeable `Y` type will be some kind of zero-copy deserializableÁ üðU R abstraction, potentially with an owned variant (like [`Cow`](alloc::borrow::Cow),Á üÆ‚ [`ZeroVec`](https://docs.rs/zerovec), or an aggregate containing such types), and the cart `C` will be some smart pointer likeÁ üÉŽ ‹ [`Box<T>`](alloc::boxed::Box), [`Rc<T>`](alloc::rc::Rc), or [`Arc<T>`](std::sync::Arc), potentially wrapped in an [`Option<T>`](Option).Á Ø Ë üÜ d a The key behind this crate is [`Yoke::get()`], where calling [`.get()`][Yoke::get] on a type likeÁ üÁ
|
|||
|
|
a ^ `Yoke<Cow<'static, str>, _>` will get you a short-lived `&'a Cow<'a, str>`, restricted to theÁ ü£ p m lifetime of the borrow used during [`.get()`](Yoke::get). This is entirely safe since the `Cow` borrows fromÁ ü” r o the cart type `C`, which cannot be interfered with as long as the `Yoke` is borrowed by [`.get()`](Yoke::get).Á ü‡
|
|||
|
|
i f [`.get()`](Yoke::get) protects access by essentially reifying the erased lifetime to a safe local oneÁ œñ
|
|||
|
|
when necessary.Á … Ë ü‰7 4 See the documentation of [`Yoke`] for more details.Á 2D\zƒ¼Ý³µ … ¶ À î… Ç ( êæ¶ Ô ì¯µ Ž í†C¬
|
|||
|
|
ï†C¾ 5 ï,/2¤Ò üË8 5 Types for optional pointers with niche optimization.Á „Ë üˆN K The main type is [`CartableOptionPointer`], which is like `Option<Rc>` butÁ ü×M J with a niche so that the resulting `Yoke` has a niche. The following fourÁ ü¥7 4 types can be stored in the `CartableOptionPointer`:Á ÝË \á 1. `&T`Á |í 2. `Box<T>`Á tý 3. `Rc<T>`Á |Œ 4. `Arc<T>`Á œË ü O L These four types implement the sealed unsafe trait [`CartablePointerLike`].Á üðK H In addition, all except `Box<T>` impl [`CloneableCartablePointerLike`],Á ü¼@ = which allows [`CartableOptionPointer`] to implement `Clone`.Á dÚ ðæl‰ Ô ìÐ6\Û ‰ Ð6 Š Î<÷ � StableDerefÁ\˜ £4�
|
|||
|
|
¤‚€ÌÍo”ìOü„ 8ü‘ "d” �� Î �à ó î�Á üæ«éå2 ™ ©âå2 ¡
|
|||
|
|
å2
|
|||
|
|
¤º DÁ –3 ƒ \Ù <Ý „ë 4õ ªâ œë –\ –\ |†Bü™: ü˜8 5 An object fully representable by a non-null pointer.Á ÑË dÕ # SafetyÁ âË ¼æ Implementer safety:Á þË ü‚\ Y 1. `into_raw` transfers ownership of the values referenced by StableDeref to the caller,Á üß( % if there is ownership to transferÁ üˆW T 2. `drop_raw` returns ownership back to the impl, if there is ownership to transferÁ àË üä_ \ Note: if `into_raw` returns the sentinel pointer, memory leaks may occur, but this will notÁ üÄ lead to undefined behaviour.Á åË üéX U Note: the pointer `NonNull<Self::Raw>` may or may not be aligned and it should neverÁ üÂV S be dereferenced. Rust allows unaligned pointers; see [`std::ptr::read_unaligned`].Á œª –\ü™Ø ž\ \¿ ž\ 4Í –\4 äb) òb –\C äb8 òb/ ©â ž\ L¶ ´c D¶ üÚD A The raw type used for [`Self::into_raw`] and [`Self::drop_raw`].Á¡ ¥ ¨ ¯ 8° 4© t£ » ü‹( üÅ. + Converts this pointer-like into a pointer.Á¡ ú ý „ 8° 4þ tøDŽ ž\�� Î �à ó î�Á üæ«é¼c
|
|||
|
|
ž\$—ü¿0 ü¹7 4 Drops any memory associated with this pointer-like.Á õË dý¢\ ŽË ”– Caller safety:Á Ë üµE B 1. The pointer MUST have been returned by this impl's `into_raw`.Á üÿ( % 2. The pointer MUST NOT be dangling.Á¡ ® ± ¸ 8° 4² t¬DÉ Ýe†3
|
|||
|
|
ž\à <ÒüóB üó? < An object that implements [`CartablePointerLike`] that alsoÁ ü³E B supports cloning without changing the address of referenced data.Á ùË dý¢\ ŠË ¼ŽÁ\ ¦Ë üªK H 1. `addref_raw` must create a new owner such that an additional call toÁ üö4 1 `drop_raw` does not create a dangling pointerÁ ü«G D 2. `addref_raw` must not change the address of any referenced data.Á ä„ –\üóé ž\ œ¢ –\& íl –\0 íl% ü¨ 2 ì¼ Clones this pointer-like.Á Þ Ë dæ ¢\ ÷ Ë ”ÿ ˜f – Ë üž E¾f üè (Œg¡ — š ¡ 8° 4› t• T² Ýe†3
|
|||
|
|
ž\à <½ äÞ ® ™ ©âƒ0 ç ý/ ã
|
|||
|
|
üÚ 0 ® ™ ¦o ê ý/ æ "$ D‘ – ƒ0ü² Dµ ý/�� Î �à ó î�Á üæ«éƒ0
|
|||
|
|
®ƒ0$¾ ü€!(DŠ! Ýp†3
|
|||
|
|
®ƒ0 _pointerÁD“!üË"9 ® ™ ¦o Û"ý/ ×" ü™#*T£# Ýp†3
|
|||
|
|
®ƒ0ñpD®#üÄLB k " " ©âÚ0 ÉL
|
|||
|
|
7 —
|
|||
|
|
8 ™ 9 8 7 9 à1í ™T” æ1í Î|T¯ ªâÎ| à ì à1 ŒŽ ©âà1 Ø ì æ1 Œ© ©âæ1 Ü™1:; í î ; 57 #% np \Ñ4Ö 6 6 Î|¬æ,é ¯ ¯™1 ¯Î| 6 ï 6
|
|||
|
|
;à1æ1Î|$ðTŠü»® Ž
|
|||
|
|
> —
|
|||
|
|
? ™ @ @ > ? Ä|T³ Ø|TÎ é| Ï à1 \ƒ æ1 \˜ ù|Œ ˆ}Ç ˜}ŒÈ §}Ë™1 Y[ ü«l Ž
|
|||
|
|
B —
|
|||
|
|
C B C ˆ}· §}» Ôà1 lò Ôæ1 l‰™1 ,. 24 Ä¢ ¤¦ K ManuallyDropÁdÛ íÑ D Fú:\é �Ò D G†,‡ ì D I DerefMutÁDŽ ù D JüÏ&XZHJäû<>%'ü¯ 0 ”Á ™ L L “[ Ô å2<× ¼2 ’yHG| ÿC M [') ´Ü4ÜD K K î;ü÷& ™ O O “[ ü Á‚<ÿ¼2PQ ü²* Æ å2¼2 N N
|
|||
|
|
På2· h üÌ#TÚ ¼2å2 N N
|
|||
|
|
Qå2$åüÚ0 ™ S S “[ ß Á‚<â¼2TU í î U \‘4– R R å2¬´,· ° °¼2 °å2 R ½ R
|
|||
|
|
Uå2$¾ü�3 ™ W W “[ ¢ Á‚<¥¼2X ú X üå!Lè ± ±¼2 ±å2 V ò V
|
|||
|
|
Xå2$÷üÞ/ ™ Z Z “[ ã Á‚<æ¼2[ � [ ”¢$¥ ² ²¼2†3 Y ª Y
|
|||
|
|
[å2$¯|¼ \À … D× À \ ] î… ( \ ] ê memÁ$÷ Õ \ `œ€dý íÑ \ a÷ � ê \ b|Ðküå1E ñ79')Ü™t¦ µ Ÿ » ¼ *¾ Á œ 3 + Ë Ì Ó 8þ 4Í 8 Ý 8¥ Là é ï ê 8 $ë (ñ ô 8 $õ 'ù 8Ø 4û ‚ � 8 $� + § ¨ ¯ 8þ 4© 8 ¹ 8¶ |¼ Ë Ð 8 $Ì (Ò 8 $Õ 'Ù 8Ø 4Û â ý 8 $ð + ‡ ˆ � 8þ 4‰ 8" 4™ 8 8Í $£ § º 8 thisÁ $¨ & ¬ 8 $® '² 8Ø 4´ (¼ 8 $¿ Ä ß 8ë‹ $Ò + é ê ñ 8þ 4ë 8 û 8Ù lþ ‹ 8Ú Œ � Ž ¡ � :® � 8 “ 8 $— $ › 8þ � & ž 8Ú 8$ ,« 8Ú ½ & ¾ :7 <À È 8
|
|||
|
|
Ê Í :©
|
|||
|
|
Î Ð 8› 4Ò Ø í Ù :©
|
|||
|
|
Ú 8 Ý 8 $á 'å 8Ø 4ç $ î ø – 8þ † ‡ Œ 8 $ˆ % � Ü¡t® ½ Ð Ã Ê , Ä 8” Å & Ç 8” È *Ì Ï Í
|
|||
|
|
8" 4Ù 8 $à ä :® å ç 8… Dé ñ :® ò ô 8
|
|||
|
|
ö , ú 8” û þ Ç 8! $Œ 8Ø 4‘ ˜ 8 $š % ž 8Î t¬ º » ¼ % ½ % Î üˆ%Ä• ® Ì ´ µ *· º É , 8 Ä 8¥ LÇ Ð Ù Ñ :® Ò 8 $Õ (Û Þ :® ß 8 $â 'æ 8Ø 4è ï � 8" 4Ù à ÷ 8ø‡ â 'å 8ù Lç ð õ 8 $ñ 8 Œ 8¶ |� ž £ 8 $Ÿ (¥ 8 $¨ '¬ 8Ø 4® µ ± 8 debug_assertÁ dÃ Ï Ð ‰ 8ø‡ Ñ 'Ô 8é <Ö 'Ý ß 8 $à 'ä 8Ø 4æ ì í î ð 8ø‡ ó 'ö 8é <ø 'ÿ � 8 $‚ † ‡ ˆ % Š 8" 4ô û § 8 � 8÷ ‘ & ”
|
|||
|
|
– 8 ,— 8 $� '¡ 8Ø 4£ ª ¬ Á 8 $® 8 ³
|
|||
|
|
¶ 8 ,· 8 $½  8 castÁ $Ã Ç È % É 8 Û 8 ß á 8œ€ dã 'ï 8• ñ ô ù 8 $õ % ú 8÷ Œ '� 8 readÁ $‘ • ™ 8÷ – 8" 4¼ 8 à 8Í $Æ Ê Ý 8ï $Ë & Ï 8 $Ñ 'Õ 8Ø 4× (ß 8 $â ç ” 8Ó” dõ � ‚ » 8ø‡ ƒ '† 8é <ˆ '� ‘ 8 $’ '– 8Ø 4˜ ž Ÿ ¢ 8ø‡ ¥ '¨ 8é <ª '± ³ 8 $´ ¸ ¹ º % ¼ 8 Ê 8÷ Î & Ñ
|
|||
|
|
Ó 8 ,Ô 8 $Ú ß á þ â 8ï $ã 8 è
|
|||
|
|
ë 8 ,ì 8 $ò 'ö 8Ø 4ø ÿ 8ã— $€ „ … % † 8 ” 8 ˜ š 8œ€ dœ '¨ 8• ª ² 8ï $® % ³ 8" 4ò ù Š 8÷ û 'þ 8ï˜ $€ „ ˆ 8÷ … 8 Ÿ 8Ù l¢ ¯ 8Ú ° ± ² Å ³ :® ´ 8 · 8 $» $ ¿ 8þ Á
|
|||
|
|
Y V the cart serves little purpose except to guarantee that `Y`'s references remain validÁ ü£ d a for as long as the yoke remains in memory (by calling the destructor at the appropriate moment).Á ˆ Ë üŒ ` ] The primary constructor for [`Yoke`] is [`Yoke::attach_to_cart()`]. Several variants of thatÁ üí Y V constructor are provided to serve numerous types of call sites and `Yoke` signatures.Á Ç
|
|||
|
|
Ë üË
|
|||
|
|
c ` The key behind this type is [`Yoke::get()`], where calling [`.get()`][Yoke::get] on a type likeÁ ü¯aªM ü‘c ` lifetime of the borrow used during `.get()`. This is entirely safe since the `Cow` borrows fromÁ üõa ^ the cart type `C`, which cannot be interfered with as long as the `Yoke` is borrowed by `.getÁ ü×a ^ ()`. `.get()` protects access by essentially reifying the erased lifetime to a safe local oneÁ œ¹ùP ÍË üÑl i Furthermore, there are various [`.map_project()`][Yoke::map_project] methods that allow turning a `Yoke`Á ü¾c ` into another `Yoke` containing a different type that may contain elements of the original yokedÁ ü¢A > value. See the [`Yoke::map_project()`] docs for more details.Á äË üè\ Y In general, `C` is a concrete type, but it is also possible for it to be a trait object.Á ÅË lÉ
|
|||
|
|
# ExampleÁ ×Ë üÛQ N For example, we can use this to store zero-copy deserialized data in a cache:Á Ë \± ```rustÁ ¬½ # use yoke::Yoke;Á ´Ó # use std::rc::Rc;Á Üê # use std::borrow::Cow;Á ü†7 4 # fn load_from_cache(_filename: &str) -> Rc<[u8]> {Á ü¾! # // dummy implementationÁ üàK H # Rc::new([0x5, 0, 0, 0, 0, 0, 0, 0, 0x68, 0x65, 0x6c, 0x6c, 0x6f])Á <¬ # }Á ´Ë ü¸I F fn load_object(filename: &str) -> Yoke<Cow<'static, str>, Rc<[u8]>> {Á ü‚5 2 let rc: Rc<[u8]> = load_from_cache(filename);Á ü¸O L Yoke::<Cow<'static, str>, Rc<[u8]>>::attach_to_cart(rc, |data: &[u8]| {Á üˆ5 2 // essentially forcing a #[serde(borrow)]Á ü¾> ; Cow::Borrowed(bincode::deserialize(data).unwrap())Á Tý })Á ,ˆ }Á ŽË ü’/ , let yoke = load_object("filename.bincode");Á üÂ' $ assert_eq!(&**yoke.get(), "hello");Á üê5 2 assert!(matches!(yoke.get(), &Cow::Borrowed(_)));Á < ```Á $³ Ò � k ‘ ‘ � ©â±6 ¸ ©â·6 Ñ � À±6 � ¤»ø5 9+¼%+}A ’“KM ¿NP üÔ DÔ ƒ Ž Ž Æ?<Ô"$Ô"ƒ Ž Ž ·6üâ#“ Ò • k — — • ÒÈ ç# âÈ €$ – À±6 – ¤ê# à`·6 „ƒ$ ˜ à` ±6 ˜  „ä$ø5™ á` ™ jl î#uw Ã$üü$D ÿ$ ³ ´ µ ³ø5 ´Á`Á` œ Ã`è Á] Ä` bufÁÁ] Ê\É:• µê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘†3ѼѼҼ” štÀ. ” ƒ% ”
|
|||
|
|
™±6·6$„%þ Š%ü‡)a Ò › k � � › ÒÈ Œ) âÈ ¥) œ À±6 œ ¤�) ·6 \¨) ·6í <à)ø5ž¡¥§ WY “)bd ü‰?£ üï)E B Construct a [`Yoke`] by yokeing an object to a cart in a closure.Á ¹*Ë üÁ*Q N The closure can read and write data outside of its scope, but data it returnsÁ ü—+< 9 may borrow only from the argument passed to the closure.Á Ø+Ë üà+R O See also [`Yoke::try_attach_to_cart()`] to return a `Result` from the closure.Á ·,Ë ü¿,U R Call sites for this function may not compile pre-1.61; if this still happens, useÁ ü™-4 1 [`Yoke::attach_to_cart_badly()`] and file a bug.Á Ò-Ë tÚ- # ExamplesÁ í-Ë <õ-�Ç ¬�.ªÀ ´›.ÇÀ ܶ.åÀ üÖ.7‰Á ü’/!ÉÁ ü¸/KóÁ <ˆ0Æ ”0Ë üœ0Iá üê05³Ã ü¤1Oñà üø15ÉÄ ü²2>‡Å Tõ2ÍÅ ,„3ßÅ Ž3Ë ü–3B ? let yoke: Yoke<Cow<str>, _> = load_object("filename.bincode");Á üÝ3'°Æ ü‰45àÆ <Ã4�Ç Ï4Ë ü×4; 8 Write the number of consumed bytes to a local variable:Á —5Ë <Ÿ5�Ç ¬«5ªÀ ´Å5ÇÀ Üà5åÀ ü€67‰Á ü¼6!ÉÁ üâ6? < # Rc::new([0x5, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0, 0, 0])Á <¦7Æ ²7Ë œº7 fn load_object(Á ¼Ò7 filename: &str,Á üî75 2 ) -> (Yoke<Cow<'static, str>, Rc<[u8]>>, usize) {Á ü¨85³Ã üâ8$ ! let mut bytes_remaining = 0;Á ü‹93 0 let bytes_remaining = &mut bytes_remaining;Á üÃ9G D let yoke = Yoke::<Cow<'static, str>, Rc<[u8]>>::attach_to_cart(Á |�: rc,Á Ü£: |data: &[u8]| {Á üÃ:E B let mut d = postcard::Deserializer::from_bytes(data);Á ü�;E B let output = serde::Deserialize::deserialize(&mut d);Á ü×;? < *bytes_remaining = d.finalize().unwrap().len();Á ü›<. + Cow::Borrowed(output.unwrap())Á tÎ< },Á Tá< );Á üð< (yoke, *bytes_remaining)Á ,•=ßÅ Ÿ=Ë ü§=C @ let (yoke, bytes_remaining) = load_object("filename.postcard");Á üï='°Æ ü›>5àÆ üÕ># assert_eq!(bytes_remaining, 3);Á <ý>�Çt�? ·6‚«ø5 šÚ Ÿ Ÿ š ß« Ÿ? ™ ‚«
|
|||
|
|
be valid.Á üÓVJ G For example, if you're working with a `Yoke<Cow<'static, T>, C>`, thisÁ ü¢W# will return an `&'a Cow<'a, T>`Á ÊWË lÒW’¿ äWË \ìW—À ¬üWªÀ ´–XÇÀ ܱXåÀ üÑX7‰Á ü�Y!ÉÁ ü³YKóÁ <ƒZÆ ,�Z #Á ü™ZK H # fn load_object(filename: &str) -> Yoke<Cow<'static, str>, Rc<[u8]>> {Á üéZ7 4 # let rc: Rc<[u8]> = load_from_cache(filename);Á ü¥[Q N # Yoke::<Cow<'static, str>, Rc<[u8]>>::attach_to_cart(rc, |data: &[u8]| {Á üû[@ = # Cow::Borrowed(bincode::deserialize(data).unwrap())Á dÀ\ # })Á <Ñ\Æ Ý\Ë üå\C @ // load_object() defined in the example at the top of this pageÁ ü]B©Ô üô]$ ! assert_eq!(yoke.get(), "hello");Á <�^�Ç ¾^ ¯ ¯ø5 ¯ ±6 ¯  ª Â^ ª
|
|||
|
|
®±6·6$Ê^ ü•a ü¢_( % Get a reference to the backing cart.Á Ï_Ë ü×_X U This can be useful when building caches, etc. However, if you plan to store the cartÁ ü´`\ Y separately from the yoke, read the note of caution below in [`Yoke::into_backing_cart`].Ádœa ¶ ¶ø5 ¶·6 ª ©a ª
|
|||
|
|
°±6·6$ªaü‚n# üÖa@ = Get the backing cart by value, dropping the yokeable object.Á ›bË ü£b] Z **Caution:** Calling this method could cause information saved in the yokeable object butÁ ü…c[ X not the cart to be lost. Use this method only if the yokeable object cannot contain itsÁ ¤åc own information.Á þcË l†d’¿ ˜dË ü dY V Good example: the yokeable object is only a reference, so no information can be lost.Á þdË <†e�Ç œ’e use yoke::Yoke;Á ªeË ü²e& # let local_data = "foo".to_owned();Á üÝeK H let yoke = Yoke::<&'static str, Box<String>>::attach_to_zero_copy_cart(Á ìf Box::new(local_data),Á 4Ïf );Á üÚf# assert_eq!(*yoke.get(), "foo");Á ‚gË ÄŠg // Get back the cartÁ ü§g( % let cart = yoke.into_backing_cart();Á ôÔg assert_eq!(&*cart, "foo");Á <÷g�Ç ƒhË ü‹h@ = Bad example: information specified in `.with_mut()` is lost.Á ÐhË <Øh�Ç Ìäh use std::borrow::Cow;Á œ‚iÄú šiË ü¢i&ëú ”Íi let mut yoke =Á üäiI F Yoke::<Cow<'static, str>, Box<String>>::attach_to_zero_copy_cart(Á ü²j! Box::new(local_data),Á TØjÅÜ üçj" assert_eq!(yoke.get(), "foo");Á ŽkË ü–k // Override data in the cartÁ Ì»k yoke.with_mut(|cow| {Á üÙk# let mut_str = cow.to_mut();Á Ä�l mut_str.clear();Á üžl mut_str.push_str("bar");Á <Ãl });Á üÏl" assert_eq!(yoke.get(), "bar");Á ölË Äþl×ü ü›m(øü üÈm) & assert_eq!(&*cart, "foo"); // WHOOPS!Á <öm�ÇŒ‰n ø5·6 ª ª
|
|||
|
|
±±6·6$›nüêyL üÅn7 4 Unsafe function for replacing the cart with anotherÁ �oË ü‰o< 9 This can be used for type-erasing the cart, for example.Á ÊoË dÒo¢\ ãoË Ôëo - `f()` must not panicÁ üŠpT Q - References from the yokeable `Y` should still be valid for the lifetime of theÁ ìãp returned cart type `C`.Á …qË ü�q^ [ For the purpose of determining this, `Yoke` guarantees that references from the YokeableÁ üðqb _ `Y` into the cart `C` will never be references into its stack data, only heap data protectedÁ ü×re b by `StableDeref`. This does not necessarily mean that `C` implements `StableDeref`, rather thatÁ üÁse b any data referenced by `Y` must be accessed through a `StableDeref` impl on something `C` owns.Á «tË ü³tg d Concretely, this means that if `C = Option<Rc<T>>`, `Y` may contain references to the `T` but notÁ ¤Ÿu anything else.Á ü¸u[ X - Lifetimes inside C must not be lengthened, even if they are themselves contravariant.Á ü˜vW T I.e., if C contains an `fn(&'a u8)`, it cannot be replaced with `fn(&'static u8),Á üôv) & even
|
|||
|
|
fn slice(Á ü…�) & y: Yoke<&'static [u8], Rc<[u8]>>,Á ü³�: 7 ) -> Result<Yoke<&'static str, Rc<[u8]>>, Utf8Error> {Á üò�@ = y.try_map_project(move |bytes, _| str::from_utf8(bytes))Á ,·ŽßÅ <ÁŽ�Ç ÍŽË üÕŽ9�ò “�Ë <›��Ç ü§�!ä– œÍ�¨— ´å�ÇÀ ü€�&€ˆ ,«��ï üµ�* ó ¤ä�ïœ Ôý� bytes_1: &'a [u8],Á Ôœ‘ƒô ,»‘ßÅ Å‘Ë äÍ‘¿ô üî‘*åô ü�’:†‰ üÜ’A > bar.try_map_project(|bar, _| str::from_utf8(bar.bytes_1))Á ,¢“ßÅ ¬“Ë ,´“�ï ü¾“5¨ö üø“ çö ü�”1‘÷ ”Ó”Ë÷ \ê”æ÷ ,ú”�ï ü„•/ˆø ü¸•<Áø ”ù•Ë÷ \�–æ÷ , –�ï üª–1®ù üà–-éù \’—æ÷ ,¢—�ï ü¬—1ºú |â—ôú üö—8�û \³˜Îû üØ0ãû \ø˜æ÷ <ˆ™Æ <”™�Ç|§™ ø5¤ãê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘Üýù áý ñ Ú ò ù ó ñ ò ó á Íþ ·™ Àä º™ ©â‘ ½™ ô À•þ ô ¤ú™ õ ™ ¤ã ±6 õ ‰ ‰ Š Ð6 Ñ{ ·Ë…YÚ õ†3 ü›š� õ ¤ãÙ’› ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘ •þ õ ‘ü‚›&
|
|||
|
|
ð±6·6•þ¤ã‘$À™þ Æ™EH KN HK þ™Ÿšü‚¢¿ ü ŸJ G This is similar to [`Yoke::try_map_project`], however it does not moveÁ üïŸR¿€ Æ Ë üÎ a§� ü´¡I’‚´‰¢ ùƒ‚„ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘‡„ù Ḡ÷ ý ø Ú ù ù ú ù ú ø ÷ á …… §¢ —… ª¢ ©â’— ¢ û ÀÀ„ û ¤ñ¢ Åçl’£ ü ™ ‚„ ¸ ±6 ü  ‰ ‰ Š Ð6 Ñ{ ·Ë…YÚ ü†3 ü¬£” ü ‚„¿˜› ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘ À„ ü Â’—üš¤&
|
|||
|
|
ö±6·6 ¸À„‚„’—$·¢þ ½¢, ¢be hk eh õ¢°£üÖª³ ü�¨P M This is similar to [`Yoke::map_project`], but it works around older versionsÁ üò¨N K of Rust not being able to use `FnOnce` by using an explicit capture input.Á üÅ©B ? See [#1061](https://github.com/unicode-org/icu4x/issues/1061).Á ŒªË ü”ª= : See the docs of [`Yoke::map_project`] for how this works.Áüݪ! ø5™ � ±6 � Âü�‰ ‰ Š Ð6 Ñ{ ·Ë…YÚ �†3 •þ �  Üý áý þ ™ ÿ þ ÿ á Íþ ÿª ©âü� ‚« € À•þ € ¤ô¬
|
|||
|
|
ý±6·6•þü�$Ž« captureÁ<œ«þ °«jl eg ø¬·«üú³é ü³±W T This is similar to [`Yoke::map_project_cloned`], but it works around older versionsÁ ü�²Nïš üâ²BÇ› ©³Ë ü±³D A See the docs of [`Yoke::map_project_cloned`] for how this works.Áü�´( ƒ ƒø5 ü� ‡ ƒ ±6 ‡  ü�‰ ‰ Š Ð6 Ñ{ ·Ë…YÚ ‡†3 •þ ‡  Üý áý „ ™ … … „ ,ª´ á Íþ ±´ ¡Ÿ ´´ † À•þ † ¤´¶ ÅçlÕ¶
|
|||
|
|
‚±6·6•þü�$Ç´îž<Õ´þ é´rthj ln ¸¶ð´ü¬½Ð üĺT Q This is similar to [`Yoke::try_map_project`], but it works around older versionsÁ ü�»Nïš üð»BÇ› ·¼Ë ü¿¼A > See the docs of [`Yoke::try_map_project`] for how this works.Áü³½% ø5ü� � ±6 � Âü�‰ ‰ Š Ð6 Ñ{ ·Ë…YÚ �†3 ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘ •þ � ‘ ð� áý ‰ ™ Š ù ‹ ‹ ‰ Š á Íþ Ù½ ¡Ÿ ܽ ˜’ ß½ Œ À•þ Œ ¤ç¿
|
|||
|
|
ˆ±6·6•þü�‘
|
|||
|
|
the cart.Á ÊÐË üÒÐ\ Y If access to the old [`Yokeable`] `Y` is sufficient to produce the new [`Yokeable`] `P`,Á ü³ÑX U then [`Yoke::map_project`] should be preferred, as `map_with_cart` places additionalÁ ä�Ò constraints on the cart.Á ±ÒË ü¹Ò_ \ This can be used, for example, to transform data between two formats, one of which containsÁ t�Ó more data:Á °ÓË <¸Ó�Ç üÄÓ!ä– œêÓ¨— ´‚ÔÇÀ ,�Ô�ï ü§Ô\ Y // Both structs have `first_line`, which won't need to be recomputed in `map_with_cart`.Á üˆÕ0 - // They also safely implement `Yokeable<'a>`Á ¤½Õ struct Foo<'a> {Á üÖÕ$ ! first_line: Option<&'a str>,Á ,ÿÕßÅ ¤‰Öïœ ü¢Ö$€· üËÖ# last_line: Option<&'a str>,Á ,óÖßÅ ýÖË ”…× fn foo_to_bar(Á üœ×) & foo: Yoke<Foo<'static>, Rc<str>>,Á üÊ×& # ) -> Yoke<Bar<'static>, Rc<str>> {Á üõ×' $ foo.map_with_cart(|foo, cart| {Á Œ¡Ø Bar {Á ü·Ø+ ( first_line: foo.first_line,Á üçØ4 1 last_line: cart.lines().next_back(),Á l Ù
|
|||
|
|
}Á T²ÙÍÅ ,ÁÙßÅ ËÙË ”ÓÙ fn bar_to_foo(Á üêÙ) & bar: Yoke<Bar<'static>, Rc<str>>,Á ü˜Ú& # ) -> Yoke<Foo<'static>, Rc<str>> {Á üÃÚ" bar.map_project(|bar, _| {Á ŒêÚ Foo {Á ü€Û+ ( first_line: bar.first_line,Á l°Û׺ TÂÛÍÅ ,ÑÛßÅ ÛÛË ,ãÛ�ï üíÛ5 2 # unsafe impl<'a> Yokeable<'a> for Foo<'static> {Á ü§Ü # type Output = Foo<'a>;Á üÌÜ1 . # fn transform(&'a self) -> &'a Foo<'a> {Á ”‚ÝË÷ \™Ýæ÷ ,©Ý�ï ü³Ý/ , # fn transform_owned(self) -> Foo<'a> {Á üçÝ<Áø ”¨ÞË÷ \¿Þæ÷ ,ÏÞ�ï üÙÞ1 . # unsafe fn make(from: Foo<'a>) -> Self {Á ü�ß-éù \Áßæ÷ ,Ñß�ï üÛß1ºú |‘àôú ü¥à8�û \âàÎû üòà0ãû \§áæ÷ <·áÆ ,Ãá�ï üÍá5¨ö ü‡â çö ü¬â1‘÷ ”ââË÷ \ùâæ÷ ,‰ã�ï ü“ã/ˆø üÇã<Áø ”ˆäË÷ \Ÿäæ÷ ,¯ä�ï ü¹ä1®ù üïä-éù \¡åæ÷ ,±å�ï ü»å1ºú |ñåôú ü…æ8�û \ÂæÎû üÒæ0ãû \‡çæ÷ <—çÆ <£ç�Çlõç ø5¤ãÜý •ý š Ú › › š • Íþ ƒè Àä †è œ À•þ œ ¤¸è � ™ ¤ã ±6 �  �ÚÎ üÙè‡ � ¤ã•Æ› •þ � ÂÜÅé ØÎ<€ê
|
|||
|
|
™±6·6•þ¤ã$‰èþ �èÁà ÅÇ ¼èÝèüòòÐ ü£îY V This is similar to [`Yoke::map_with_cart`], but it does not move [`Self`] and insteadÁ ü�ï> ; clones the cart (only if the cart is a [`CloneableCart`]).Á ÄïË üÌïK H This is a bit more efficient than cloning the [`Yoke`] and then callingÁ üœð\ Y [`Yoke::map_with_cart`] because it will not clone fields that are going to be discarded.Á ýðË ü…ñ\ü± üæñ[ X then [`Yoke::map_project_cloned`] should be preferred, as `map_with_cart_cloned` placesÁ üÆò' $ additional constraints on the cart.Á¤ùò ùƒ‚„‡„ •¸ Ÿ ý Ú ¡ Ÿ ¡ • …… •ó —… ˜ó ¢ ÀÀ„ ¢ ¤Ñó £ ™ ‚„ ¸ ±6 £  £ÚÎ üòóŽ £ ‚„�Í› À„ £ ÂÜåô Åçl�õ ØÎ<ºõ
|
|||
|
|
ž±6·6 ¸À„‚„$¢óþ ¨ó,ŽóÞà âä Õóöóüëÿ· ü ùR O This is similar to [`Yoke::map_with_cart`], but it can also bubble up an errorÁ ´÷ù‡ ’úË üšú\ü± üûúU R then [`Yoke::try_map_project`] should be preferred, as `try_map_with_cart` placesÁ üÕû'ÃÊ �üË <‰ü�Ç ´•üÇÀ ¬°üªÀ üÊü&€ˆ ,õü�ï äÿü // Implements `Yokeable`Á ü ý+ ( type P<'a> = (&'a str, Option<&'a u8>);Á ÐýË lØý¼ˆ üêý)Óˆ ü˜þ8 5 ) -> Result<Yoke<P<'static>, Rc<[u8]>>, Utf8Error> {Á üÕþ0 - y.try_map_with_cart(move |bytes, cart| {Á üŠÿ7 4 Ok((str::from_utf8(bytes)?, bytes.first()))Á TÆÿÍÅ ,ÕÿßÅ <ßÿ�ÇŒòÿ ø5¤ãð� •ý ¥ Ú ¦ ù § ¥ § ¦ • Íþ „€ Àä ‡€ ˜’ Š€ ¨ À•þ ¨ ¤Ç€ © ™ ¤ã ±6 ©  ©ÚÎ ü耒 © ¤ã±Õ› ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘ •þ © ‘üÔ�& ØÎ<š‚
|
|||
|
|
¤±6·6•þ¤ã‘$�€þ “€!$ '* -0 Ë€ì€ü ‹í ü†] Z This is similar to [`Yoke::try_map_with_cart`], but it does not move [`Self`] and insteadÁ ü¤‡>µÇ ç‡Ë üï‡K‰È ü¿ˆ` ] [`Yoke::try_map_with_cart`] because it will not clone fields that are going to be discarded.Á ¤‰Ë ü¬‰[ X If access to the old [`Yokeable`] `Y` is sufficient to producethe new [`Yokeable`] `P`,Á üŒŠ\ Y then [`Yoke::try_map_project_cloned`] should be preferred, as `try_map_with_cart_cloned`Á üíŠ. + places additional constraints on the cart.Áħ
|
|||
|
|
Ë ü‰
|
|||
|
|
q n With this terminology, [`Yokeable`] exposes ways to cast between `Self<'static>` and `Self<'a>` generically.Á üû
|
|||
|
|
] Z This is useful for turning covariant lifetimes to _dynamic_ lifetimes, where `'static` isÁ üÙ * ' used as a way to "erase" the lifetime.Á „ Ë dˆ ¢\ • Ë ü™ b _ This trait is safe to implement on types with a _covariant_ lifetime parameter, i.e. one whereÁ üü \ Y [`Self::transform()`]'s body can simply be `{ self }`. This will occur when the lifetimeÁ üÙ
|
|||
|
|
d a parameter is used within references, but not in the arguments of function pointers or in mutableÁ ü¾; 8 positions (either in `&mut` or via interior mutability)Á úË üþ[ X This trait must be implemented on the `'static` version of such a type, e.g. one shouldÁ üÚA > implement `Yokeable<'a>` (for all `'a`) on `Cow<'static, T>`.Á œË ü L I This trait is also safe to implement on types that do not borrow memory.Á íË üñQ N There are further constraints on implementation safety on individual methods.Á ÃË äÇ # Implementation exampleÁ äË üèW T Implementing this trait manually is unsafe. Where possible, you should use the safeÁ üÀ_ \ [`#[derive(Yokeable)]`](yoke_derive::Yokeable) custom derive instead. We include an exampleÁ ü O L in case you have your own zero-copy abstractions you wish to make yokeable.Á ðË \ô—À Ì€ # use yoke::Yokeable;Á ÜšåÀ Ô¶ # use std::{mem, ptr};Á ¤Ñïœ üæ �� 솵� ¼¤Û� ,¼ßÅ ÂË üÆ3 0 unsafe impl<'a> Yokeable<'a> for Bar<'static> {Á ôú type Output = Bar<'a>;Á ü™/ , fn transform(&'a self) -> &'a Bar<'a> {Á üÉ: 7 // covariant lifetime cast, can be done safelyÁ „„
|
|||
|
|
selfÁ L• }Á ŸË ü£- * fn transform_owned(self) -> Bar<'a> {Á üÑ:Äÿ „Œ†€ L�ž€ §Ë ü«/ , unsafe fn make(from: Bar<'a>) -> Self {Á üÛ+ ( unsafe { mem::transmute(from) }Á L‡ž€ ‘Ë ü•/ , fn transform_mut<F>(&'a mut self, f: F)Á lÅ
|
|||
|
|
whereÁ üÓ6 3 F: 'static + FnOnce(&'a mut Self::Output),Á LŠ {Á ü”N K unsafe { f(mem::transmute::<&mut Self, &mut Self::Output>(self)) }Á L㞀 ,íßÅ <ó�Ç DŒ À ® Á À Á –\üû°1 ž\<š À –\# æ… –\. æ…(ÂÃÄÅÆÂÃÄÅÆ ©â ž\ ®  „€ ³† ®� «† Ȇ Æ Ä Ã Å •|€ ü¨S P This type MUST be `Self` with the `'static` replaced with `'a`, i.e. `Self<'a>`Á4… À À üã + ü– P M This method must cast `self` between `&'a Self<'static>` and `&'a Self<'a>`.Á ë Ë Üó # Implementation safetyÁ “ Ë ü› R O If the invariants of [`Yokeable`] are being satisfied, the body of this methodÁ üò X U should simply be `{ self }`, though it's acceptable to include additional assertionsÁ |Ï if desired.ÁLæ ®ž\ ®³† À À
|
|||
|
|
Þ\ ®$ô üÙ!) ü” H E This method must cast `self` between `Self<'static>` and `Self<'a>`.Á á Ë Üé ⇠‰ Ë ü‘ R‘ˆ üè Xìˆ |Å!̉|Ü! ž\³† À À
|
|||
|
|
Äž\ ®$ì!üö$+ üˆ"? < This method can be used to cast away `Self<'a>`'s lifetime.Á Ì"Ë dÔ"¢\ å"Ë üí"V S The returned value must be destroyed before the data `from` was borrowing from is.Á È#Ë ÜÐ#⇠ð#Ë üø#R O A safe implementation of this method must be equivalent to a transmute betweenÁ üÏ$" `Self<'a>` and `Self<'static>`Á$€% ³†ž\ À À
|
|||
|
|
Åž\ ®ï$…%üêJ¿ ü§%X U This method must cast `self` between `&'a mut Self<'static>` and `&'a mut Self<'a>`,Á ¼„& and pass it to `f`.Á &Ë Ü¨&⇠È&Ë üÐ&_ \ A safe implementation of this method must be equivalent to a pointer cast/transmute betweenÁ ü´'@ = `&mut Self<'a>` and `&mut Self<'static>` being passed to `f`Á ù'Ë ¼�( # Why is this safe?Á �(Ë ü¥(P M Typically covariant lifetimes become invariant when hidden behind an `&mut`,Á üú(L I which is why the implementation of this method cannot just be `f(self)`.Á üË)g d The reason behind this is that while _reading_ a covariant lifetime that has been cast to a shorterÁ ü·*X U one is always safe (this is roughly the definition of a covariant lifetime), writingÁ ü”+] Z may not necessarily be safe since you could write a smaller reference to it. For example,Á üö+c ` the following code is unsound because it manages to stuff a `'a` lifetime into a `Cow<'static>`Á Þ,Ë Äæ, ```rust,compile_failÁ ܃-åÀ Ì£-’ý „Á-
|
|||
|
|
struct Foo {Á ¤Ö- str: String,Á üï- cow: Cow<'static, str>,Á ,“.ßÅ �.Ë ü¥.& # fn unsound<'a>(foo: &'a mut Foo) {Á üÐ. let a: &str = &foo.str;Á üô.= : foo.cow.transform_mut(|cow| *cow = Cow::Borrowed(a));Á ,¶/ßÅ <À/�Ç Ì/Ë üÔ/d a However, this code will not compile because [`Yokeable::transform_mut()`] requires `F: 'static`.Á ü½0` ] This enforces that while `F` may mutate `Self<'a>`, it can only mutate it in a way that doesÁ ü¢1f c not insert additional references. For example, `F` may call `to_owned()` on a `Cow` and mutate it,Á ü�2^ [ but it cannot insert a new _borrowed_ reference because it has nowhere to borrow _from_ --Á üð2j g `f` does not contain any borrowed references, and while we give it `Self<'a>` (which contains borrowedÁ üß32 / data), that borrowed data is known to be validÁ –4Ë üž4Z W Note that the `for<'b>` is also necessary, otherwise the following code would compile:Á ý4Ë Ä…5Á— Ü¢5åÀ ÌÂ5’ý œà5¨— ,ø5�ï ü‚6* ó ¤±6ïœ „Ê6
|
|||
|
|
num: u8,Á Ìß6 cow: Cow<'a, u8>,Á ,ý6ßÅ ‡7Ë ü�7/ , fn unsound<'a>(bar: &'a mut Bar<'static>) {Á üÃ7H E bar.transform_mut(move |bar| bar.cow = Cow::Borrowed(&bar.num));Á ,�8ßÅ ,š8�ï ü¤85¨ö üÞ8 çö ü
|
|||
|
|
Ý â ï†C 5 Ý â ï\Ï¢|à�„öeüŒ W|²IüÄÄ Ò ä k å ä å ÒÈ É âÈ Ì æ À±6 æ ¤ç ç
|
|||
|
|
±6 ç  çÚÎ ü¦" ÊÎ\Ñ ì ·6 ,ß ØÎ<€ø5è � „† ë…üÜ 0 ü�\ Y Construct a [`Yoke`]`<Y, C>` from a cart implementing `StableDeref` by zero-copy cloningÁ üð= : the cart to `Y` and then yokeing that object to the cart.Á ²Ë üºY V The type `Y` must implement [`ZeroFrom`]`<C::Target>`. This trait is auto-implementedÁ ü˜\ Y on many common types and can be custom implemented or derived in order to make it easierÁ Ôù to construct a `Yoke`.Á ˜Ë l ’¿ ²Ë ¬º Attach to a cart:Á ÔË <Ü�Ç ÌèÅþ œ†Äú žË ü¦K H let yoke = Yoke::<Cow<'static, str>, String>::attach_to_zero_copy_cart(Á Ôö "demo".to_owned(),Á 4• ’ü Ë ü¨ # assert_eq!("demo", yoke.get());Á <Ð �ÇÄã ·6ø5 ã ã
|
|||
|
|
è±6·6â$ü º
|
|||
|
|
è <closure_kind>Á é <closure_signature>Á é <upvars>Á é é è é±6·6–4 ÚÎ ±6  †3¬À B!üà" d!d!v!v!ÌŒ D� ”É �!üáI# ü©GE B A type with similar semantics as `Option<C<T>>` but with a niche.Á ïGË üóGJ G This type cannot be publicly constructed. To use this in a `Yoke`, seeÁ ü¾H/ , [`Yoke::convert_cart_into_option_pointer`].Á îHË üòH] Z [`Yoke::convert_cart_into_option_pointer`]: crate::Yoke::convert_cart_into_option_pointerÁ ¬ìI k ñ ñ ¯s ‚J ¿sœ’J£0 ¶ ÓdÑåÙ òó (') ´ŠL,ŠL ð ð �� Î �à ó î�Á üæ«é Ú0 ̦LL¦L ð ð ‰ ‰ Š Ð6 Ñ{ ·Ë…YÚÚ0(ÙI k õ õ ¯sä à`Ú0 1 ¿sï à`ãÍ D£0ö á` ö ce ¸ ¹ º ¸£0 ¹Á`Á` œ Ã`è Á] Ä`£ËÁ] Ê\É:• ºÉÌ ô ÙI ô
|
|||
|
|
öÚ0,ÙIþÜœ üÊR O A cart that can be one type or the other. Enables ergonomic polymorphic carts.Á �Ë ü¡T Q `EitherCart` enables yokes originating from different data sources and thereforeÁ üöU R having different cart types to be merged into the same yoke type, but still beingÁ üÌ8 5 able to recover the original cart type if necessary.Á …Ë ü‰O L All relevant Cart traits are implemented for `EitherCart`, and carts can beÁ üÙ& # safely wrapped in an `EitherCart`.Á €Ë ü„E B Also see [`Yoke::erase_box_cart()`](crate::Yoke::erase_box_cart).Á ÊË tÎµÒ ÝË <á�Ç ¤éÑÉ üþ! use yoke::either::EitherCart;Á œ Äú ´Ë ü¸) & let y1: Yoke<&'static str, Rc<str>> =Á üâO L Yoke::attach_to_zero_copy_cart("reference counted hello world".into());Á ²Ë ü¶^ [ let y2: Yoke<&'static str, &str> = Yoke::attach_to_zero_copy_cart("borrowed hello world");Á • Ë ü™ M J type CombinedYoke<'a> = Yoke<&'static str, EitherCart<Rc<str>, &'a str>>;Á ç Ë üë Q N // Both yokes can be combined into a single yoke type despite different cartsÁ ü½
|
|||
|
|
6 3 let y3: CombinedYoke = y1.wrap_cart_in_either_a();Á üô
|
|||
|
|
6 3 let y4: CombinedYoke = y2.wrap_cart_in_either_b();Á « Ë ü¯ ; 8 assert_eq!(*y3.get(), "reference counted hello world");Á üë 2 / assert_eq!(*y4.get(), "borrowed hello world");Á ž Ë ü¢ Q N // The resulting yoke is cloneable if both cart types implement CloneableCartÁ Äô let y5 = y4.clone();Á ü�
|
|||
|
|
2 / assert_eq!(*y5.get(), "borrowed hello world");Á <À
|
|||
|
|
�Ç T¥ Ž
|
|||
|
|
ø —
|
|||
|
|
ù ù ø ˆ}° §}´™1 Q£^Ÿ
|
|||
|
|
áúûýþ û ü à1™1 þ ÿ æ1™1 JL PR ‚ ‚ ÷ ÷
|
|||
|
|
ûà1æ1‚ ‚ à1™1 ÷ ÷ ÌÞÀ ÷ ÷ à1Ô Ô ÷ ÷
|
|||
|
|
þà1æ1Ô Ô æ1™1 ÷ ÷ ¼ßË ÷ ÷ æ1( Ñ
|
|||
|
|
Ž
|
|||
|
|
� —
|
|||
|
|
‚ � ‚ ˆ}x §}w Þà1 H Þæ1 U™1ƒ ß ƒ ©¬ ±´ ƒ… » »™1 ™1 € Ñ
|
|||
|
|
€
|
|||
|
|
ƒà1æ1,Ñ
|
|||
|
|
H
|
|||
|
|
Ø
|
|||
|
|
Ž
|
|||
|
|
… —
|
|||
|
|
† † … ˆ}Q §}P™1 ]` eh ^ b Ž
|
|||
|
|
ˆ —
|
|||
|
|
‰ ˆ ‰ ˆ}¬ §}« žà1à1 ¦ žæ1æ1 ¶™1Š Š ãæ ëî äæ ¼ ½ ¼™1 ½™1 ‡
|
|||
|
|
Ø
|
|||
|
|
‡
|
|||
|
|
Šà1æ1LØ
|
|||
|
|
î N ã
|
|||
|
|
Ž
|
|||
|
|
Œ —
|
|||
|
|
� Œ � ˆ}¢ §}¡ £à1 H £æ1 U™1Ž ¤ Ž ÓÖ ÛÞ ƒ¡ŠŒ�‘ 8° › Ÿ¡ ¾ ¾™1 †3 ‹ ã
|
|||
|
|
‹
|
|||
|
|
Žà1æ1ã
|
|||
|
|
( ç
|
|||
|
|
Ž
|
|||
|
|
� —
|
|||
|
|
‘ ‘ � ˆ}— §}– à`à1 H à`æ1 U™1’ á` ’ ÈË ÐÓ ƒ… ¿ À Á ¿™1 ÀÁ`Á` œ Ã`è Á] Ä`£ËÁ] Ê\É:• ÁÉÌ � ç
|
|||
|
|
�
|
|||
|
|
’à1æ1,ç
|
|||
|
|
þ4ø
|
|||
|
|
Ù$ ® ” ” †3•–—˜™ Â Ã Ä Å Æ ™ — ˜ –
|
|||
|
|
åX
|
|||
|
|
Π0
|
|||
|
|
‘ “ “ †3øÝ$Hà  †3  †3 ®  “ ê “
|
|||
|
|
– ® ëø¹(x¼ †3›ê “ “
|
|||
|
|
— ® Ìø™* £ ›ê†3 “ “
|
|||
|
|
˜ ®ë‹ ¨øûthþ ®†3Ú†3 “Ú š š “ ©â•ì Œ •ì8À › ™ •ì ››ê øÊ$ › •ìëì› †3àÒ
|
|||
|
|
™ ®•ì —þ�tv ÎøÙ$ ® � � –3žŸ ¡¢ Â Ã Ä Å Æ ¢ ¡ Ÿ åXŒ 0‘ œ œ –3øÝ$Hà à Ö3 à –3 ®  œ ê œ
|
|||
|
|
Ÿ ® ëø¹(x¼ –3�ï œ œ
|
|||
|
|
® Ìø™* £ �ï–3 œ œ
|
|||
|
|
¡ ®ë‹ ¨øûthþ ®–3•ì†3 œÚ £ £ œ ½ìŒ Ïì8À ¤ ™ •ì ¤�ï øÊ$ ¤ •ìÃñ› †3àÒ
|
|||
|
|
¢ ®•ì —þ�qs ÎøÙ$ ® ¦ ¦ ¦3§¨©ª« Â Ã Ä Å Æ « © ª ¨ åXŒ 0‘ ¥ ¥ ¦3øÝ$Hà Ä Ä¦3 Ä ¦3 ®  ¥ ê ¥
|
|||
|
|
¨ ® ëø¹(x¼ ¦3Ùó ¥ ¥
|
|||
|
|
© ® Ìø™* £ Ùó¦3 ¥ ¥
|
|||
|
|
ª ®ë‹ ¨øûthþ ®¦3•ì†3 ¥Ú ¬ ¬ ¥ ½ìŒ Ïì8À ™ •ì Ùó øÊ$ •ì›ö› †3àÒ
|
|||
|
|
« ®•ì —þ�qs ÎøÙ$ ® ¯ ¯ ¶3°±²³´ Â Ã Ä Å Æ ± ´ ² ³ åXŒ 0‘ ® ® ¶3øÝ$Hà ŠŶ3 Å ¶3 ®  ® ê ®
|
|||
|
|
± ® ëø¹(x¼ ¶3±ø ® ®
|
|||
|
|
² ® Ìø™* £ ±ø¶3 ® ®
|
|||
|
|
³ ®ë‹ ¨øûthþ ®¶3•ì†3 ®Ú µ µ ® ½ìŒ Ïì8À ¶ ™ •ì ¶±ø øÊ$ ¶ •ìóú› †3àÒ
|
|||
|
|
´ ®•ì —þ�qs ÎøÙ$ ® ¸ ¸ Æ3¹º»¼½ Â Ã Ä Å Æ ¼ º » ½ åXŒ 0‘ · · Æ3øÝ$Hà Æ ÆÆ3 Æ Æ3 ®  · ê ·
|
|||
|
|
º ® ëø¹(x¼ Æ3‰ý · ·
|
|||
|
|
» ® Ìø™* £ ‰ýÆ3 · ·
|
|||
|
|
¼ ®ë‹ ¨øûthþ ®Æ3•ì†3 ·Ú ¾ ¾ · ½ìŒ Ïì8À ¿ ™ •ì ¿‰ý øÊ$ ¿ •ìËÿ› †3àÒ
|
|||
|
|
½ ®•ì —þ�qs ÎøÙ$
|
|||
|
|
® Á Á Ö3ÂÃÄÅÆ Â Ã Ä Å Æ Å Ã Ä Æ åXŒ 0‘ À À Ö3øÝ$Hà Ç ÇÖ3 Ç Ö3 ®  À ê À
|
|||
|
|
à ® ëø¹(x¼ Ö3á� À À
|
|||
|
|
Ä ® Ìø™* £ á�Ö3 À À
|
|||
|
|
Å ®ë‹ ¨øûthþ ®Ö3•ì†3 ÀÚ Ç Ç À ½ìŒ Ïì8À È ™ •ì Èá� øÊ$ È •ì£„› †3àÒ
|
|||
|
|
Æ ®•ì —þ�qs ÎøÙ$ ® Ê Ê æ3ËÌÍÎÏ Â Ã Ä Å Æ Î Ì Í Ï åXŒ 0‘ É É æ3øÝ$Hà È Èæ3 È æ3 ® Â É ê É
|
|||
|
|
Ì ® ëø¹(x¼ æ3¹† É É
|
|||
|
|
Í ® Ìø™* £ ¹†æ3 É É
|
|||
|
|
Î ®ë‹ ¨øûthþ ®æ3•ì†3 ÉÚ Ð Ð É ½ìŒ Ïì8À Ñ ™ •ì ѹ† øÊ$ Ñ •ìûˆ› †3àÒ
|
|||
|
|
Ï ®•ì —þ�qs ÎøÙ$ ® Ó Ó ö3ÔÕÖ×Ø Â Ã Ä Å Æ Ø × Õ Ö åXŒ 0‘ Ò Ò ö3ø Ý$H à É Éö3 É ö3 ® Â Ò ê Ò
|
|||
|
|
Õ ® ëø ¹(x ¼ ö3‘‹ Ò Ò
|
|||
|
|
Ö ® Ìø ™* £ ‘‹ö3 Ò Ò
|
|||
|
|
× ®ë‹ ¨ø ûth þ ®ö3•ì†3 ÒÚ Ù Ù Ò ½ì Œ Ïì8 À Ú ™ •ì Ú‘‹ ø Ê$ Ú •ìÓ�› †3à Ò
|
|||
|
|
Ø ®•ì —þ �qs Îø Ù$
|
|||
|
|
® Ü Ü †4ÝÞßàá Â Ã Ä Å Æ ß á à Þ åX Œ 0 ‘ Û Û †4ø Ý$H à Ê Ê†4 Ê †4 ® Â Û ê Û
|
|||
|
|
Þ ® ëø ¹(x ¼ †4é� Û Û
|
|||
|
|
ß ® Ìø ™* £ é�†4 Û Û
|
|||
|
|
à ®ë‹ ¨ø ûth þ ®†4•ì†3 ÛÚ â â Û ½ì Œ Ïì8 À ã ™ •ì ãé� ø Ê$ ã •ì«’› †3à Ò
|
|||
|
|
á ®•ì —þ �qs Îø Ù$ ® å å –4æçèéê Â Ã Ä Å Æ ê è ç é åX Œ 0 ‘ ä ä –4ø Ý$H à Ë Ë–4 Ë –4 ®  ä ê ä
|
|||
|
|
ç ® ëø ¹(x ¼ –4Á” ä ä
|
|||
|
|
è ® Ìø ™* £ Á”–4 ä ä
|
|||
|
|
é ®ë‹ ¨ø ûth þ ®–4•ì†3 äÚ ë ë ä ½ì Œ Ïì8 À ì ™ •ì ìÁ” ø Ê$ ì •ìƒ—› †3à Ò
|
|||
|
|
ê ®•ì —þ �qs Îø!Ù$ ® î î ¦4ïðñòó Â Ã Ä Å Æ ó ñ ò ð !åX!Œ 0!‘ í í ¦4ø"Ý$H"à Ì Ì¦4 Ì ¦4 ®  í "ê í
|
|||
|
|
ð ® "ëø"¹(x"¼ ¦4™™ í í
|
|||
|
|
ñ ® "Ìø"™* "£ ™™¦4 í í
|
|||
|
|
ò ®ë‹ "¨ø"ûth"þ ®¦4•ì†3 íÚ ô ô í ½ì"Œ Ïì8"À õ ™ •ì õ™™ ø"Ê$ õ •ìÛ›› †3à"Ò
|
|||
|
|
ó ®•ì "—þ"�qs "Îø#Ù$ ® ÷ ÷ ¶4øùúûü Â Ã Ä Å Æ ù ü ú û #åX#Œ 0#‘ ö ö ¶4ø$Ý$H$à Í Í¶4 Í ¶4 ®  ö $ê ö
|
|||
|
|
ù ® $ëø$¹(x$¼ ¶4ñ� ö ö
|
|||
|
|
ú ® $Ìø$™* $£ ñ�¶4 ö ö
|
|||
|
|
û ®ë‹ $¨ø$ûth$þ ®¶4•ì†3 öÚ ý ý ö ½ì$Œ Ïì8$À þ ™ •ì
|
|||
|
|
°øµ!Nšª¿ÄÊÏᕱãK Rc<[u8]>Á
|
|||
|
|
alloc::rc::RcÁ alloc::rcÁ Ó Yoke::get()Á Yoke::getÁ alloc::boxed::BoxÁ alloc::boxedÁ Rc<T>Á “
|
|||
|
|
alloc::borrowÁ Ÿ» ¬» Ó ø° Option<T>Á Ñ» Box<T>Á ï» …¼ “ alloc::borrow::CowÁ ¥¼ Ÿ» std::syncÁ μ Ñ» € https://docs.rs/zerovecÁ â¼ ï» “ á Cow<'a, str>Á þ¼ ¥¼ std::sync::ArcÁ ¡½ μ € ZeroVecÁ À½ â¼ ¯ .get()Á
|
|||
|
|
Yoke<Y, C>Á ò½ þ¼ á Arc<T>Á �¾ ¡½ € ¾» ³¾ À½ ¯ Ỡо Û¾ ò½ á –¼ û¾ �¾ ¬» ¾» ³¾ Ó ¯ Žá» о Û¾ …¼ –¼ û¾ * std::ptr::read_unalignedÁ std::ptrÁ Self::into_rawÁ ¡" Self::drop_rawÁ ö &Yoke::convert_cart_into_option_pointerÁ -crate::Yoke::convert_cart_into_option_pointerÁ ¯ crate::YokeÁ “ ´ £À ÀÀ ¡" ðÍÀ ö åÀ ýÀ ¯ ¨Á ßÁ “ ´ £À ÀÀ ÍÀ åÀ ¡" ö ýÀ ¯ ¨Á “ ßÁ Ž ´ ßÁ crate::Yoke::erase_box_cartÁ Yoke::erase_box_cart()Á ¯ ßÁ ´Ã ¯ Øà ßÁ Ž´Ã Øà ¯ � Yoke::attach_to_cart_badly()Á Yoke::attach_to_cart_badlyÁ Ó Yoke::new_ownedÁ Yoke:: wrap_cart_in_option()Á Yoke::try_map_projectÁ #1061Á 0https://github.com/unicode-org/icu4x/issues/1061Á Yoke::try_attach_to_cartÁ ¹Ä Ó ø° Yoke::new_owned()Á õ" þÄ .https://github.com/rust-lang/rust/issues/86702Á ³Å ÍÅ _ ŒÆ ¹Ä Yoke::with_mutÁ ºÆ õ" #86702Á ÛÆ ³Å Self::wrap_cart_in_either_aÁ _ Yoke::try_attach_to_cart()Á ŒÆ Yokeable::transform_mutÁ ªÇ ºÆ õ" ÷ Yoke::map_with_cartÁ ÈÇ ÛÆ ¯ ßÇ Ð¾ _ ƒÈ ¨È ÆªÇ $stable_deref_trait::CloneStableDerefÁ ÚÈ ÈÇ æ ¯ Self::wrap_cart_in_either_a()Á Ỡо Yoke::map_project()Á ƒÈ ßÇ Yokeable::transform_mut()Á ¨È Yoke::new_always_ownedÁ ®É ÚÈ … (æ ¯ Ž Self::wrap_cart_in_either_bÁ Ỡо Yoke::map_projectÁ ›Ê íÉ Yoke::with_mut_returnÁ ¿Ê ãÊ ®É … Ñ» .map_project()Á á» ÏË ›Ê æ Ô£Ë Yoke::into_backing_cartÁ ñË ¿Ê íÉ Yoke::new_always_owned()Á ãÊ Self::wrap_cart_in_either_b()Á … À£Ë Yoke::attach_to_cartÁ Ñ» ÏË ¬Ì Yoke::try_attach_to_cart_badlyÁ áÌ ñË �Í Yoke::try_map_with_cartÁ ²Í äÍ Ñ» ¬Ì �Î áÌ Yoke:: wrap_cart_in_optionÁ �Í † Yoke::try_map_project_clonedÁ ÄÎ ²Í Yoke::attach_to_cart()Á äÍ Yoke::try_attach_to_cart_badly()Á �Î „Ï † Yoke::map_project_clonedÁ ®Ï ÄÎ ÛÏ ÚÄ üÏ ’Å „Ï ×Å † ì ¶Ð ®Ï ÛÏ ÚÄ üÏ Ó þÄ ’Å ÍÅ ×Å ¶Ð Self::transformÁ ¨È #[derive(Yokeable)]Á yoke_derive::YokeableÁ … à Self::transform()Á ¿Ê ¨È ×Ñ õÑ Ã ¿Ê … �Ò (±Ò ¨È Æ ×Ñ õÑ … À�Ò Ã ¿Ê ±Ò †C
|
|||
|
|
†C 5¯ ¯ Ž†C ¯ À Ô
|
|||
|
|
ªJ�ýþ „ ޣÞÉôñú÷Ä� “ – ™ Þ á æ òJ©K·J®JÞK¨â©âåâ Ô ªJ�ýþ „ ޣÞÉôñú÷Ä� “ – ™ Þ á æ òJ©K·J®JÞK¨â©âåâ Ôì ªJ�ýþ „ ޣÞÉôñú÷Ä� “ – ™ Þ á æ òJ©K·J®JÞK¨â©âåâ Àì ÔªJ�ýþ „ ޣÞÉôñú÷Ä� “ – ™ Þ á æ òJ©K·J®JÞK¨â©âåâ ÀªJ�ýþ „ ޣÞÉôñú÷Ä� “ – ™ Þ á æ òJ©K·J®JÞK¨â©âåâ ì× ó5$ÔÂU´ÊUŒ"Å$nÃ$ ÔUC»ß»ð½ÃŽ#ÝTËU›ÌÛñ€M:ôØԾɅé�z;v?�–ù2:éxõaiCïý/¿‚‡ ¢±"D�¸¿âƒÈx-úìåÈÑ‰Û Ô2ëbnMX=»”ÞÀì‹7’N „Ï%¦Ô»~ñÔCX�fœËr·äZgãŒvŒBh ¬|äÃÅò~ãY9›#°…<¢¾Õ„g+÷C(¯ZdJÛÔ£µ$YûÓQ5*+¾”rV,7–ëS*0×æ×ç©lÊΨ2w¼�éj"±I™£³K¨2ð }ãå'Ê'%½
|
|||
|
|
&döÁÜ·–ù¡ !¥¾—Æ["ÇŽoäü#C“8{™q7ZD?Ãì„(
|
|||
|
|
žÒœã9×Q Ð/.h=3~&¢�¤ÕQ�0¶6>Súȳc2Ý=»v6 Xr/ë4O¢‘·“OÆ4öA
|
|||
|
|
NElƒ7!¿Âî‡K½NÞNÖÇD馋ñ¼µ»,h¤÷'Žqn`û¡+¼»‚"¿p}}õ¶@Ë#4xU.Ê] !×Y¡ÂRÿÙk§7*û/ReƒSë°,ÔˆœsM ¬fÒÂú»®g |·oát¸„ ý?™jšz”
|
|||
|
|
ÉGf5f† I®ãÌ’®‘=WLJUθŒª›»ë?Aîvª¬«1Y`iñÍÃäÐCƽBOËR¶ÉÇG_üÏ!/2HX#D�˜mS“êâø×G®UòSF ˆˆ�kù 4d…®ƒQÙØúúþ¾¹¨¬ÑƒW�&ë°ž‘‡IUŽa¹×ÛÊ3 âã £õK m#â¿dwîˆa.pâ”ì‡6ºF xÊîî 4Q ç>2\®Q–;
|
|||
|
|
…osýQ %IÜ y½b1ž�6êÅV¨Û*�åGaQUøH`ÄZžxÒºËØð¸=ŒPÚÃFÿÚ<º™‡I@b]0m<Qp¹Òúž,°¦áÞÝþgrd~² à'( â–5šÉ5W2 tB&³‹Éé[dý[¹c:¼ß&‡»–ÜQUÙ ˜w®"Fq�Ußß}>º/Þ�PrêE·C‚âH¤NµäS²/•6QÇ|‚ÏŸÚï÷}«45d¤ŒÙ‰Žñ‘àèÏ©Mg»Ð Æ»þ��SµaÀ¸Ì8Y²û£~ýÕ Ú¥Ú“T ªcï…,ûûWíyûÜ}& ´5+óG.»JèTðhÀϡʸ8žœÔ V€cBälÐV ñýq ÞúŽ}òo¥ÔÖºÝLYä1ÿR OV`ô 7à ¤ ã^ŠiJÚìûÑÆC¶ÿã_#¸¯-ø¶Z¼"¾É `=þ”ÎYrNÊÿZ›)9òŸíLze¥KÛÎób§ö-b‘7è=OxÁhÊ?Ò} ä ËË H=rœÃò!ÙÍë‚«s*kˆUW-ô* üXÛÝŸóÉC-L[ÇÄéì1 –
|
|||
|
|
»Wí•9”bíÎE)S×ã9ZcÁ™A½óE` ¿?Ý)`á×ýí%®8ë>Œ†R"ÇÂéR¤Üb—RÊ»Ê “Ft þ ÌþûK-Y#ŽÏzbÙ*
|
|||
|
|
wu+šð±|ì>™ìÁ èôBÜ伂—…úšÜD‡\·€¥ ¾¥ Û¹(Á¦ òD7ßVx\‡å·^Þï|ºº£ÒËþt€‡œhy¬m -£ ‹cºw½-EçéŸ ¹÷Wó4Î ]<aÕXâöᵚ(r=ž÷¥[9¼ðÅ¿Ñ™e‚eçœ%b”È®»üs\p]Ô%Î Æ^ÞA·[ÑîR v
|
|||
|
|
È^)px1¡i"±@àw»WmxøÜ‚[º:m̉‹ û=[¢·æP)œÃ'¿fDCÑáqÈ7û´Ë]âci•ž,e&=8ðœ™ÿœaÝÔ^3·Å0ѵŸ!Ù`k Âß³ÊÀõW�ë-ç¯hnÂpªÅVæIÐÐâ¹°Oˆ�_úMÒÐ/YÎ;CdV^:”$"Åãó“BâÔât íÀ·rLì>%Ö$1)T§ÅÁéˆþšÿ«ªãTöI'ÛtSí�ÞQXÎxiCà’&ÅfÚ¼¼÷ç„�zÖ°…GŸ>\i²}ÈCŸ~hæûœ«¼ÜX)3Çĸf˜`É#9 &E#QšVÇ¢™q¼h0˜ñ{‡�yxn²…0� Þ¶/+-g"ù¾U´š^$u2Wf3‚©2Ó¢E
|
|||
|
|
A $C(f½Ï(¹É<i Ós¬»¶#¡pÅÚ‡ÝEÝO¤Ü¬jO�XW Ý�&ÆÁmm¼¨¹$’±Y—ñýõñZ}/ÿjˆ¤UÈX ÂO £l‚ø¼¹‡jA'Ôkw¦€Km «‰ÓËBŒBYGsÏTÞ0½— 1zÙÒ[`Y$yÕ>¤n
|
|||
|
|
Sö/Ä„û³8ÐÄSÓ›õÆo@Í?è4‡>Ó£¥Zg~/,›,{¶GP#"Ô†ã`“uï HG ¨Ã>y-wðªÛ áOÿ·tÜš˜bë8�ε÷Ü[Äòr‡m4O2þ�N‘ñ³c²�¯®^qu%þ-ãTÙT¿ªª
|
|||
|
|
"3ó½R–Ë�Çb§së{lÓ�´‘ ZÓ{½Ä5ƪ™*ÖP·’ #]ð›` ŠˆÏ7‚låFWÜÜrb{˜uB£L?S/ÛÚØŠ�*mj‘ücc|e2 ;è`�9,/êÏ÷;álxôOÒ¹ã®ãa6ñ@8ˆ½-j �ÿÕütæ $[õ7Qï§_ L]¸:@ çÜIœ:–²" HŠ9¶mð;"ésí*¡¼¸úšB®¡B"_GS…å�ô=´''1ª�bi žBZõ®E¸2XS¿ ý<}Á,ÈQ£H1@‰ònzD.Zý6ÁQÿ-B-Úp&lšçZ@4¥\k.² 1@Zw>Æüê{îÖˆ« º}y@gÝA
|
|||
|
|
yÊHÊÜæ…ó;µTØ<—ÎÈLgôÑ·‡T^ãÏMJÓÁÐ�C�7L¥rFr&Æ„‰ó”– …Ü›@ÃæYDƒey£Tâµ~ù{e†k·7‚ß[ë3@ùÛÑ>ÂE ¦V� “îÆ¢J5±kÁÆ|[0’õgüÔ uÏÑ ó=DÁæxïèö½B'ÌŸx£üÃá‘Ý„‡ðMg=—ë{W“Ü©2Ê?¸M›§ÀUWSMxÚ½Àâê™ÈÚóß]×& FÄiØ›¨UŽ¡ÁŠf”Zý�‡f©I7†¨$8¨kL, ÍÝ{J3Ñõ$~¦h› Q˜ ;j.Þàr*%�ü˜9kÑü :ÏÒè+ÿ6r¸�[ΛÉé´þ(J©E{¡1 uRT’8�Fû)zuD9ÛGhd+º*r»4ºÂ´Ö©&˜D^&9| ”8j4±iâ`Ä5«¼NûˆÑ!žô|épö>ÕºõQï×�˯ :G¹Þ~Š
|
|||
|
|
M¨„µÇúÊ7yÖhÑ©T
|
|||
|
|
Š ÿ çÝvù¼Óríwšæ”2^Ôðë`‹ƒhÕ’é
|
|||
|
|
›WX1Û_ØìŒê ¨Œ›ü?°zø- =¡L+ÊùØÛ «„¡�ÿSJRs¯øyé_ݾËØDªUùë*Út ¡îˆxñA^ŠPؼNdãÞ� JÏÐÉ`˜ Þl}�ÆKÈ ÕÎÑ’wÑ·ß'G T²étÖBŸPÝj³BJ ¥¸j†´Eý…ÄÔüíCÖ7¸JÙfëôoRtÞ*¯°5 ›¦’8Šv o¡DÍcŒÓY
|
|||
|
|
rò õ� W´·‰’=†�*Ä Ou)^Þ4F"b‚r´mý±ö ªv ·²ôÊÅ(àáÿ^ò’uKÇpkÝå=[-Mq‹÷ðµ9«Ñyrb,rÅC»v©0…HŠß®þvdÏw¾`Õòi6|FgDfËá÷¥›¤©±"ùy9ó|pg×Ý~fèˆä¼©ö7ÿkŸb€}B±£ÿX<ðvÓ7 ŒžÄ(‚ BTˆcÍø·ê&8X
|
|||
|
|
vo†xt6âVð€¨X]ŸaÕµR^e(uŽ7> ¡Ó®ÔϾhc8sŽš)ÞŠ‚ÛCæjåÕ¡EøO‘ïÑZïLg›83í%]@ Ë.=–°%“ö>pÁì—F[ ÞÚ w÷òZºõ›wÌ (<@RÞ¢÷¿ž¼?3€�ÔÙ¤ƒ¹‡ µœÜÀ9ô!ª‘Ý_‚"!â±}–ZB±ñ3žá`sc¶ä'j¼°’§©çiJerØ6óGî´ò rœçòÌÂÜNÎ+GSÀé
|
|||
|
|
¶2H¾ }óJÞ㺶 Ñþ©L?m TÑÕ¸ˆâ’�ÂçÊfv¡æ�’¢Š…F®•«.Ÿá˜_¶
|
|||
|
|
Ë`
|
|||
|
|
É3—O^2IÙ [ÕÎ0Nsº–;ìÑÏåãdPHÎápÚÖQ2êåsªµ5É€H:÷#A¦þgx’úRésÅ£`ç!Oûm6b#¹`mÝOÎê\m€)"µg gX>HZïŸ�ð„ä œ&Æ H\>íM#a^ùhïÝ®Í\šCb©•2ì!ŒÁA–â@•Ûí3¼¥èéaÙrÃ…ìÙ8H�ë¶ÛáYŸ÷Œ¯àr_|(Ùòˆ²jÕßZTþ lÎÆ;„K[g‰ë ²dœVè·V P>#½P ÂL—ÌRp�±À³ƒ‰êñqYe¸›•A–Þ¦Âe”S 1`Wg® BNž›?~¸ò29†o[ŠÏ’Úe‹k4BP¨«ð!ÃÚÊ¥›6I½ó—ƒcü3 $j>ÔµÀä#� ¿R˜8ñWï¢VG«@¹°¨ûÞ‡z÷¥öât7mÉ‚tT=¥èú×!žÀo¿‚wTSL`RAFTE?âdæMŽç;õváð äZ”´Îã>{Ï>€è¥qZ÷e1Б@¨;�“þEòœ"K5[¯#¿Øg GE
|
|||
|
|
â�Wg'U WZ†~NœìÁp'†Š.›èÑÌ?£“« üÊøì�@e £À•
|
|||
|
|
A‡~ì;&ÐqÈRñ¼!ÐV òØÒÀv”Ÿæg¥²/‘›�úß½¥Ôªn:öj•;uáVdL3 oa䌊,�SÅ&m22\´E‡?П䢿E½!Xÿ½ jwE69*FóÇ€÷ŽÑ{Þ
|
|||
|
|
g~ÄB!:î&ÜoZ.Æ¢ÈÉ#‹_eBVUa³_:SÚo>IiãžhõöCåsÊ¡z�ˆ‘�—&‡†™MÑäj¸Ë﹇žÏ“Kc €w]±6”®×7
|
|||
|
|
ÚÒît„^ò*’oo7f6ÆÊɜ݃"»»o#ªmù›§dÜ¢>šþks�èfAí²‡yÄßÏ1Smôn…�~ب[¼§ðܹ}!¨WjMkjŽ÷A®øÜß=å„u¶wz9}`¸èzx€6|{IÝNÆ©&qnL{Ãíå|ÂquuC8?›ç&9ÎRĸ\«ûÅ ^õþ@—2|)ý9� W
|
|||
|
|
ÝAÝeœ¶òNâQçyÇr^¥NŸA]¹Ãþ0²þŽ5¯j· *ô×·aÁf…p_é% Ó¤6©w;FåÖßÏ.N˜ó¯’—/&8eqÜZ‚7::FçAn<µ&Çøyê!}& ¬fwäó¤]3í¾+Õ(yï7ö›ºÏŸŠo ̇§ZSøb×^®ó oÍsŒÀ7çäÒ‘âZ•!ê±RÓ]Ú%¢)¾ i1@ôœBeï®dEñC°®ó,ИšNÆl1ghÀ�L¬¥ûh-à `–±[ùRa• `Ö½9OshwÝTwºË�ܶQîö¶ÙnWIB«>©À š óà›ŸÁé<È:ô°C_” ;œþÈ Oá›Û¾�ß$C†¨±*B`Ù½RjkLà°ÛPt5š„þËÒ!ˆßØ¡n,�YÄ™7b›68N2[±Å¢ 7Z¹�Šâõ"·ãŒ×ÃpÊ~Á€’20íº}Æ8¿µ�’LdàyùÏÎГXdã=¥s$�Ãs¹JóéõÓà²PŸ@k%4 ×ðà^¶Ëj¿™›„± ) M0Òq‘
|
|||
|
|
RÏs#÷ždì¦b–Ä–F¡_ô\^�ÃvQ8ª$ë)EÌlaS-c‘ÚTwúÊÒ h·ök¢nAŸÃ[Ü9ç “ÎhXÞåOݲw–ZÂa_ÿ QüN>–è©¡¦í%T©&=a¶\Ó’£hYUææ·ÈÂr¼ùt6T•�Ä„/Ì8´´ý¢�ü¢ò ¦ ¦3Á†„¯—&DøbfæÕ¡M‰;ÜZÓV× <Îí<Q¦ŸüDïš’)a¶ÑÞÚ²#jF¿µÜTö\:ø†ŒØ) šÈ&Ê¥¢)mÍXfBx)<ûI¿ã`ü;ÎÃSh^iå{# › 31 ª I1 Ö ¶- 1 6
|
|||
|
|
] ‡] ä( , >= @ ËC †T j V -ô æ
|
|||
|
|
4 ) 6 7 P 7 ¨ 7 À 7 4 8 „ 8 Ð 8 9 f 9 ž 9 ç9 ÿ : @ ; “ ; Û ; . < v < ¾ < = ’ = s > Š > ô > ¡ ? @ › @ ô @
|
|||
|
|
A L A � A Ð A B 0 B � B Ñ B . C q C à C T D É G ÷ H b Q R k R i S Ÿ S _ T } T Ø T X V ‘8W M d h d … d E e u f Dg p År òs B u Ó u z f1{ û� >‰ “ Ì– m — ˜ ‰› ³ œ :� äŸ W ¡ ê/¡ ž © ,ª L« Í ¯ ° h ° { ° ´ ³ ´ ¬A´ ä¿ E;à Ê
|
|||
|
|
Í ´Ï þÑ “Ô ` × ^Ø G ã Þæ M ë L ï Óï ò ß ó ö ó
|
|||
|
|
ô # ô �Lô u 3
|
|||
|
|
Ôs Î Q k Ã
|
|||
|
|
X 8 » Õ : … Ò ¥ ¬ � ¥ # t$ " & o & ¯& ' Á$' ¸ . / ( / ‚ / š/ 0 s0 Î0 T 1 Ä1 D2 ¹2 9 3 ñ 3 J 4 f 4 Ú 4 $ 5 p 5 W 6 ° 6 Ì 6 @ 7 Š 7 Ö 7 ¯ 8 9 $ 9 ˜ 9 â 9 . : ; ` ; | ; ð ; : < † < _ = ¸ = Ô = H > ’ > Þ > · ? @ , @ @ ê @ 6 A B h B „ B ø B B C Ž C g D À D Ü D P E š E æ E ¿ F G 4 G ¨ G ò G > H I p I Œ I J J J – J o K È K ä K X L ¢ L î L Ç M N < N ° N ú N F O P x P ” P Q R Q ž Q w R Ï R ê R \ S ¥ S ð S È T U ; U U ö U A V W W Ë W X ó X ] Y Y þ Y Ý Z J [ � [ ñ [ Ù(
|
|||
|
|
, u- À - ,1 6 <= @ Ë C …T `V Æ ¯ +ô • æ m. À - /1 6 7 7 {7 ¯8 N9 %; À; c < « < ô < 8> t ? ó ? à@ 5A øA µB VC ²Q S T $d e êf ˜u ë— � ¿¡ ª Æ ¯ °
|