platform-admin/boc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9e4ebeea1aa4679ca00b951fdc58d376419ce821
boc/aamos-ledger-rust/target/release/deps/libyoke-9075b36b0667a440.rlib
T

526 lines
231 KiB
Plaintext
Raw Normal View History

ARCHITECTURE: NFC roadmap, edge AI, audit logging
2026-06-29 16:24:48 +00:00
!<arch>
/ 0 0 0 0 74 `
– _ZN4yoke12cartable_ptr12sentinel_for8SENTINEL17h2e2039482f75b078E// 58 `
yoke-9075b36b0667a440.yoke.8614287134f7899-cgu.0.rcgu.o/
lib.rmeta/ 0 0 0 644 234848 `
ELF·à“@@GNUÀrust
<‘#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁstable_deref_traitÁ¼­P¹¶/$:
Žð‹'¸-546c51b4cc13a0b4Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁ yoke_deriveÁ.š8>².œ”Š=—ÇIˆ*è-6cc2b2ac601b2455ÁzerofromÁõ3�uô¤q¯ê/JÕ?y-17ad948a2616d91bÁzerofrom_deriveÁ4ö¤˜#i}¹=_ècqŽ»-04750c2d0037dbcfÁ‰¤,Ì»¤Œ«BoxÁÄ»¤ŒžÆò»¤ŒÏK¡»¤Œüa$Â$¬testsÁ, a‚$•aerasedÁ4œ»¤Œ€€
ErasedArcCartÁlß»¤Œ·€
ErasedBoxCartÁl$&€ ErasedRcCartÁdý»¤EG€øŒ»¤Œæ€Æº»¤Œ—€K黤ŒÄ×o›»¤Œó×ToOwnedÁ< »¤ í cartable_ptrÁ sentinel_forÁ¥SENTINELÁprivateÁ SealedÁCartablePointerLikeÁRawÁinto_rawÁdrop_rawÁCloneableCartablePointerLikeÁ
addref_rawÁ'aÁ¥Ô¥ôþ�Ô¥¿!”!Œ
!
from_cartableÁ!is_noneÁ&”&ã)”)ƒ,”.”0”eitherÁ22226C0Á6C1Á6¥6å6´;2=º =Ã =¥2Aº AÃ kinda_sorta_danglingÁDDDDDDDKindaSortaDanglingÁK¥KdangleÁDN¥Næ N
into_innerÁDR¥RåR´DV¥VDY¥Yã macro_implsÁ\\\\\copy_yoke_implÁ\impl_copy_typeÁ\unsafe_complex_yoke_implÁ\dÔd¥d'bÁd°\iÔiT1ÁiÍ iT2ÁiÍ i°\pÔp¥pÍ pŸp p°v utilsÁxxtransform_mut_yokeableÁzÔzªz—z£zÍ yokeÁ€€€€€€€€€€ €
€YokeÁŒªŒÔŒ”ŒyokeableÁŒcartÁ€’ª’Ô’”’Ô’×€˜ª˜”˜Ô˜Ô˜×€žªž”žÔžÔž�€¤ª¤”¤Ô¤Ô€©ª©”©Ô©Ô©ï
€¯ª¯”¯Ô¯Ô¯‹€µªµÔµ”µattach_to_cartÁ¹—¹'deÁµtry_attach_to_cartÁ¼–¼—¼Òµattach_to_cart_badlyÁÀÒµtry_attach_to_cart_badlyÁ–ÂҀŪÅÔÅ”Å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Á€ ߪßÔß”ß new_ownedÁßtry_into_yokeableÁ€
åªåÔå”å convert_cart_into_option_pointerÁ€ êªêÔê”êä€
CloneableCartÁ€ ð¥€
òÔò¥€€öªöÔö”öÔöƒ€üªüÔü”ü map_projectÁ€¡€—€Ô€Ôü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Á©º©¡©¥©–©Ô©Ô€°ª°Ô°”°
map_with_cartÁ´¡´—´Ô´Ô°map_with_cart_clonedÁ¹º¹¡¹—¹Ô¹Ô°try_map_with_cartÁ¿¡¿—¿–¿Ô¿Ô°try_map_with_cart_clonedÁźšŗŖÅÔÅԀ̪ÌÔÌ”Ìwrap_cart_in_either_aÁГÌwrap_cart_in_either_bÁÒ’€€€õ××YokeableÁÙÔÙ°Ù transformÁÙtransform_ownedÁÙmakeÁÙ
transform_mutÁß—ßÍ ×âÔâ¥â°â� â® âÅ âÑ é—éÍ ×ìÔì¥ì°ì� ì® ìÅ ìÑ ó—óÍ  zero_fromÁööööööüªü”üÔüÔüattach_to_zero_copy_cartÁ� CartableOptionPointerÁ‰”‰innerÁ‰ _cartableÁ �”�×2
EitherCartÁ�º �à �’“
“ˆ�“–
–ˆ2™º ™Ã ™ƒ2�º �à 2 º  Ã  �2¤º ¤Ã ¤Ö2¨º ¨Ã ¨×\¬Ô¬°¬� ¬® ¬Å ¬Ñ ²—²Í \µÔµ°µ� µ® µÅ µÑ »—»Í \¾Ô¾°¾� ¾® ¾Å ¾Ñ Ä—ÄÍ \ÇÔÇ°Ç� Ç® ÇÅ ÇÑ Í—ÍÍ \ÐÔаÐ� Ю ÐÅ ÐÑ Ö—ÖÍ \ÙÔÙ°Ù� Ù® ÙÅ ÙÑ ß—ßÍ \ âÔâ°â� â® âÅ âÑ è—èÍ \
ëÔë°ë� ë® ëÅ ëÑ ñ—ñÍ \ ôÔô°ô� ô® ôÅ ôÑ ú—úÍ \ ýÔý°ý� ý® ýÅ ýÑ ƒ—ƒÍ \
†Ô†°†� †® †Å †Ñ Œ—ŒÍ \�Ô�°�� �® �Å �Ñ •—•Í \˜Ô˜°˜� ˜® ˜Å ˜Ñ ž—žÍ \¡Ô¡°¡� ¡® ¡Å ¡Ñ §—§Í \ªÔª°ª� ª® ªÅ ªÑ °—°Í d� d® dÅ dÑ —Í i� i® iÅ iÑ ¼—¼Í p� p® pÅ pÑ Â—ÂÍ %
(
+
;
U
X
[
—
—
—
�
�
�
£
£
®
®
´
´
Ë
û
�
�
�
œ
£
£
§
«
«
«
¯
¸
Á
Ê
Ó
Ü
å
î
÷
€
‰
’
›
¤
­
ïÙ  Ô¥¥1¥1¿c‰‰š#‹¿#ŒÌ#HíyœbŠLt”Œ"Ë1ØË1ïË1ÌìË1� Ë1Ø�“”’•ˆ–—“˜ˆÐKZ^÷º à ÐìÃ2µßÃ2Ã2™Ã2¿cÃ2é!Ã2Ã2ïÃ2é!KKÃ
Mã
DEhcí ªkî¥ö!è3Œ"è3ÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ«1ÔÙè ø ÔÙ«1ŸÔ¿cŒŒÑ�õ€‘…€³uÈxc¨”ª”Äc¦7µß¦7¦7™¦7íߦ7¦7º¦7ïÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ’4ï¥1ï³4ئ7Ù «1ÔÙ• • – PhantomDataÁFu\»Ÿ«1Ô


�‰¨�’Œ&‰YK)‰™�öŒ,‰A�ðÛ¼ò
õ
.‰0‰�� �žŒ¤�¤Œ6�RK=�VK¬
µ¾ÇÐÙâëôý†�˜¡ªdÛ¼i
pâ
ì• ˜Œ©Œ¯Œ ›¿cŒ"Ø ïÌì� Ðìµß™é! ö!ÙÄccíߺDÐ

  Ã4*üÐ
 ’4ü¹
7´¹

ž’41$ô
ü‘ ㉉§‹‰ ïíe¼îËè¿*’4T© ª=” Ã4¬Ð
û<Üý<ãfÁ=¨\à $å 
è «1‰‰§‹‰ ïíe¼îËè¿*«1$à 4å ñ ü¶ ;€?TË ú>$  ,ô>¤í!ü„!i³4¬!€?D—!_pointerÁ5ˆ$ ü�#k³4Ç#€?D²#Ç? -(ÝI  °’L ÉA‰‰§‹‰ ïíe¼îËè¿*ƒ2Z ¿cÈ®L  ÉA
• • – »8Fu\»Ÿƒ2L 
X µBõú
ûc ˜�0âI�H Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
³4ŸÈŸÈ ÈErrorÁ O˜éBLÐ Ë1Û  c cˆ¢cµ
 `£cbufÁ `àB¤GS
"ÉA*ÉAµB# ñA.ÉAµBÊ  åBØ“Fàu±ƒŽöEµBƒ‘FµB·C¨ĤN´¤N
ŸBüŠNa ‰ƒ2åBñN#üãMŽË1$ûMñAlüF|œŒPD•P
ƒ2DŒPT•PüäPG ‰ƒ2‘åB±Q$üÅOìü€P±ù ‹‰ ù çŸ Ë1$ñOƒ2DáOñA,„PöEA Œ öEI – ǽȽɽ}ʽ˽NeÁ̽ͽMatchÁBÙe±æµé! ë cartableÁŽ¿#’left_valÁœ right_valÁ¥‚U„HvüFÄÁP
·ßñAñA¹ ¹ 
òWñAñAù –] T¤SñAIJS´²SüFü¤S&÷JRB ÐS%üüRT$•SŒE,‹SöE“öE…ñAŒ @üF¨÷JƒTÛTñAòTÄùT´ùTüFüòT
¸ßñAñAWL*0ĈW´ˆWüFüûV%ñA„ýW\ýW
ƒ2‰X$ŸX(ü´TëüÑTγ4ÆT Ë1L¼TñAÕTàöE!öEñA!ñA¿9µ =süFPËM,üFò¾NÆT¹YñAÐYÄ×Y´×YüFüÐYËMMB &”ß[lß[
ƒ2í[$T \ñAü†\S ‰ƒ2.åBß\+ü�YÒü¯Y° Ë1$ YŒE,–YñA³Y³4üÍY°ãöE$öEñA$ñA¤Dµ H{üFSËM/‘Qÿ(
Ñ
"
Ë“‘3!
Ù‘32:
À’‹3!
Ù‹32:¤ �‹3‘3
Õ
Ê �‹3‘3&
Ö
œ
Ã2 Ã2%ó5- ‹3Ò‹3Ù ‘3!‘3)[__self_0Á óTU†ÚSh˜T0 H Ø
*8 H«UW d t|ˆ‘—«U¦³Á«UÐÝ Ë«U“‘3)«U8“‘3O[in
·ßÏUÏUƒˆ� À«U
’‹3)«U8 ’‹3O 
[
 in
·ß¾U¾U ƒ
ˆ� á
£&,3:AM«UU«U]ó5eó5mt«U«U€ó5ˆó5�ó5˜¾U!¾U) ¾U4Û[<ÏUØÏUà ÏUëþ[ó«Uæ«Uî«Uö«Uþ«U«U«U ¹
. __self_discrÁH __arg1_discrÁ`óTí
__arg1_0Á óT¡¤\­¡ŒYÀ Z2 å
§ ã
³4«U!*4(
ç
"
Ë“‘3B JÉA, 8
 µBrw
‡dˆ �
jš
À’‹3¸ÀÉA,8µBèí¾_ùþe 
ì
«#)0 ˆD=«UE—EMó5U¾U¿ÉAdµBÎÛ[ÕÏURÉA‚µBbþ[jœ±ªóTóTœÍþ[µB±¾_ßÛ[µBI¾_í$§T¡# Û“‘3Lá,ã
ë!‘3 á<ã ¼’‹3LÂ,Ä
ë!‹3 Â<Ä* Ê… éü¡Tû;üæ•ŒºŒÙ ¥ù«U,ïÔdVó5$º¾U×ÔdÃÏU*Ôd9¬­U‰ŒcLÑc
Äœ„œ
ñ’44­%üóL K’4ÅPü¾‡è3$ä’44ÖÑÛÑÛ MaybeUninitÁÓÛuninitÁÝÔÛ»ÝÍõƒ«%9’4Ãã
b„íeàêÕÛ
 íe& ³
 K’4 ¾
Pè3’4Ïf‡’4tã
/R¼ÚŒÚ
¼è3$ì%4ºlº
ë!ÃÛÃÛ ManuallyDropÁÅÛ»¬„µÜÀ,�%*è3e]aÏfüº „È
ø’4�”ÈâQüØŠüÍ•’4 úè3$ñÞi4Ñ Ïfå è3ï Þi 3manualÁ=p¢i`Øi-Ïj¿\€Ïfì€|Œ
ú’4/ŒŒ¥UüÀå ’4Óµk,É«kr7­ly\ÁÏfìÁ|Í
û’40ŒÍæXüñõ ’44Œ è3Lþ Ïfy=Çm\§ Ïfħ T³ 
ö’40d³ ü§ (lÀ 
ø’4E|À à [ü®²³4ÀŠnL¶³4[ª=Œ–n© Bçn¯’oŠ ý‹¯øÊA ³4háÅp(× 2ë°ø¦E³4`³4 ¹ ³45ͱø†G³4 ¬³4 •thisÁj³4:8ó ó
™"— ³4;C„²ø蜳4�Úr`üÒrŠØrˆ± NÌr± ý‹¸øÊAý<háý<(× / Ýë¹ø¦EÃ4`ÂÃ4 ¹ / ¿Íºø†GÃ4 ¬Ã4 •ˆq
08ó ó
™"Òr Ã48@„»ø蜳4�±v`üÒrŠ¯v…± N¦v® ý‹ÁøÊA Ó4háíw(× 2 ÝëÂø¦EÓ4`ÂÓ4 ¹ / ¿ÍÃø†GÓ4 ¬Ó4 •ˆq
08ó ó
™"Òr Ó48@„Äø蜳4�‹z`üÒrŠ‰z…± N€z® ý‹ÊøÊA ã4háÇ{(× 2 ÝëËø¦Eã4`Âã4 ¹ / ¿ÍÌø†Gã4 ¬ã4 •ˆq
08ó ó
™"Òr ã48@„Íø蜳4�å}`üÒrŠã}…± NÚ}® ý‹ÓøÊA ó4há¡(× 2 ÝëÔø¦Eó4`Âó4 ¹ / ¿ÍÕø†Gó4 ¬ó4 •ˆq
08ó ó
™"Òr ó48@„Öø蜳4�¿�`üÒrŠ½�‡±!P´�± ý‹ÜøÊA ƒ5háþ‚(× 3 ÝëÝø¦Eƒ5`ƒ5 ¹ / ¿ÍÞø†Gƒ5 ¬ƒ5 •ˆq
08ó ó
™"Òr ƒ58@„ßø蜳4��…`üÒrŠ›…‡±!P’…± ý‹åøÊA “5há܆(× 3 Ýëæø¦E“5`“5 ¹ / ¿Íçø†G“5 ¬“5 •ˆq
08ó ó
™"Ò
 DÎüÍ& ªÛüÍ-$ô
ŠʊÊA4ôüÇ3 ‚ 
$‚ 5
™"¤² ŠÊP6?ˆüè  ‡ z3ü¶R
£ ¸ �ÊDš¤² ¯¢Ëê‰Ê!‰ÊK �ʔΤ²ÿ Ëè“õR±UÄÆÌ«Ê„–Ë,¤²Ø4÷%
ÉA´è%dê%
÷c è%6¤ê%.T’&
ÉATž&£&
Éà7æ7$ž&
,£&- 
µBüè%A,Œ&
Ù`¬v eìŒ&4½& 
ÉAœÅ&dÊ&
Ëà7æ7$Å&
tÊ&- 
µBüè%q,·&îΟ p _ü·&"üè%‡4ç&
à`NDç&õ&—ü™%܈DŒÌ% ¦7, %—E §% Í`Í` DebugStructÁÐ`×µ`Ñ`� µ`Ò`
has_fieldsÁµ`ã¹q·Ù›ß¨ú€Ñ‹€Ñ$‚Ñ-ÉAKÉAµBô à7ÛÉA�µB� æ7šÜ±àÝÍ ®ÎV™ÒµB_îÎ'·Ïä½ÒµBíîε©Ð‹Tó(ø(®Î$ó(,ø(üÛ(&¼Û(
Åc›ÒC ÿ(+‡)�üŒ({ˆDŒ¿(ëÐ,“(—E š(™Ò“± K®Î½èÓœT¹*¾*®Î$¹*,¾*%\Ç*Í*®Î,Ç*,Í*%̹*
·ß™Ò™Ò„V+Ø*£üŒ*L$ª*ëÐ,’*ëÐ,™* ™ÒÕ™ÒÝÐÖ²™Òº8¹
;f®Î®ÎëôÕ¾Tž-£-®Î$ž-,£-\µ-»-®Î,µ-,»-üž-#\©-
ïߛқÒoMÄ©-Ç-®üÑ,vÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¿ßÀßÁßLessÁÂßÃßÄß~ÅßÆßÇßGreaterÁÈßåºÝÈnûê7Üø,ëÐ,à,ëÐ,ç,™Òe™ÒG'¹
*û®Î™®Îy�ØYTý.‚/®Î$ý.,‚/\Œ/’/®Î,Œ/,’/Üý.ˆ/
»›ÒiG„ˆ/ž/´üÀ.^—Ùœß.ëÐ,Ç.ëÐ,Î.™Ò»™Òœ%¹
(U®Îí®ÎÌÄÛ« d×V 
 æV 
$èVdèV,íV
ë!æ7*<íV|æV  #€
™"¤² æ7ê!¡NW ôV 
¬ÚY<ÚY
Þà7dâY (üœW伜W
Pà7 üÑY ($ŽZ
üÿVž Œà7æ7
£Z ¢Zü¡R‚ÉÙ ¹2üÓVÐ ¦7$ÌRæ7$ºR¤² ÃR›Ò褲Ý�ÞŽ‘ÞÀ½ÒÙKKÃ
Mã
DEhcí ªkîà73à7æ7Ž…Œ±� deserializedÁ† ½ÝW…Þ5ØÞˈߤæ7C¤²õdË^
 Ú^
$Ü^ dÜ^,á^½Ý %<á^|Ú^ #{
™"³½�Þ‘CL è^
€<Ú^
ž$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
›Ò–Ô w{
‡
™„Ú^ l›Ò) dÚa
¬Òa<ÒaØÞ7=é^ [Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ˆê)?ÈXM´­øä–…
¡$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¦7øä¾æ ì   ›b

ü”_ä¼”_ˆßüÉa  $$†bü÷^ž
Œà7æ7üô^¢ Ö¿¦7øä
œ¤°
œbà üä\¸ß ï
& 7 ¼TüÇ^Õ07>½ºç|–]æ7$„]³½ �]›Òf•¢˜¢™¢lš¢ˆ›¢œ¢[�¢ˆe0<#˜¾æ›Òá¦äP³½¬�Þb‘Þ�½Ò¨ó5ÿ¾æ›Ò‰¦7Åýàà7ó›Òwæ7ôHv…ø±ûäàeŽ { ¹ÿ Ã
½Ý<Úã äÀØÞÓ´çÎæ7Èߥæ7ЛÒ׳½ìæd¤æd
¹à7æ7 “Þà7Û$ûd �eQ‰eÀüÍc¼¦7$×dæ7$òc«î ƒd…±EŸîüôg!Äôg
¼à7æ7øä°îÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ºîøä$�h “h•›hÂü¾fݺç|Úgæ7$êfóï ûf…±Fãïûl�rýàÌ�r
ë!ýà/!'L«r
Üà7W\«r¼rÉü×qe™ÒüóqëÐDæq à7‡ ýਠDûñ¯¢òµTàtæ7ðtËüµt;½ÒÓtëÐ,Ét .LÐ�æ7 Þ�ýàß�Ìü¢�=æ7 Ä�¦7$»� /ýàa
Dø�   ' /9 Al•ŽýàüƒŽ ŒƒŽ
¼ýà4( ¸Ž  LºŽ  æ7d¸Ž [
™"Þæ7t5>üŸ’"ÄŸ’
½ýàD¸’ +$Ï’
üÎŽ� Œà7Ô 
ä’ ã’  ü��Ç0@ Pæ7ÍGüô�ðü­Ž·
ŒŒÑ�õ€‘…€³uÈxc¨”à7ø÷\Þ�¦7$¼�ƒ÷ Â�ÃÛÃÛêhÅÛ»¬„µÜÀ,�%*ýà�ýà[ø÷$±Žƒ÷.‰÷óæ7ýàÀø÷šahŸ±¡õ…l}ƒöÎýöe·÷(ø÷Àƒ÷Çæ7Íô–¨ l–¨ýà?D
÷!ýà/_ ²¨ …l¤¨
ßà7³½}F„¤¨»¨ü‰§² º¨Ð6³4³§ ¦7d §³½ ®§³4) à74 ýà³½æ|D±F©¶üyÿü€³½´œÙ­ lß­ýàtÞ­¶ü, î­ ü»­5ì»­
zà7³½£ªO6ö­ü†¬ð õ­Ô6 € ¾¬ûýd§¬³½ µ¬›þí¦þ
³½Ým6±8š¶ü.’€ò³½¤¼ž°d£°
Íà7æ7Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙæ7
à¼æ7$ž°$°°ê‚ ”£°½°ÙüܮጌÑ�õ€‘…€³uÈxc¨”à7¢‚”€¯¦7$÷® n–‚ü¡¹!¼¡¹ˆßD¹¹$üÙ·Š Œà7³4)#³4é¹Ýü¢·ÇŒŒÑ�õ€‘…€³uÈxc¨”à7³4$Ê·à7Dº·ýàÆõvˆßälÖ¼ýàÔÖ¼Tä¼
Qà70dä¼ö¼Þü»»»à7 Ù»¡…$лýàx9Ć€üŠÇ!¼ŠÇˆßD¢Ç$$¿Ç Û¼æ7ü›Æ³ Œà7¢‚ÔÇãüåÅï·ƒ$ŒÆà7DüÅýà�¢‚}õBˆßÃͺÀä
ëçˆßä ªÇìò Û¼æ7ï Œà7¢‚ ÍÇ ùðãþ·ƒùà7öýà�à7¢‚yõ@
LîÊ '¢‚|èÊMl³ËýàÔ³ËTÁËĆ, dÁË$•Ë L‘Ë Ö¿à7·ƒ ™Ëô°Ë Ö¿à7·ƒ ÍË ÞËüŸÉÀ&ßË=¢‚Q¢‚äYÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
à7·ƒ|ÁÉ·ƒ$¸Éó5<†Ë·ƒaà7�ýà®7Ć¿¢‚'¢‚.
L–Ú¢‚|�Ú)l÷ÝýàìœÞÜœÞ
#æ7 $³Ú¢‚Ûæ7l‚Üýàü§Ü*ü§Ü$
$æ7$ÌÜ*ü¼Ú¤ Œà7‰‰š#‹¿#ŒÌ#HíyœbŠLtæ7 ßÜüöÜÒ Œà7¥‘ ÇÞÙÞ V ü³Ù¦éü®Ú²ŒŒÑ�õ€‘…€³uÈxc¨”à7¥‘üäÙ!·ƒ$ÛÙó5T®Úæ7©ýà•¥‘‰ýàý¥‘ñB…äËœ�ô�ÌýàýàP œÜá '/9ALÜᥑa<æá
%æ7. Læá‹l�â ýàÔ�âT�âĆ> d�âôþá Ö¿à7÷’üÙát$¾â 'Lºâ Ö¿à7÷’^ Òâü�á&Óâ=¥‘Q¥‘fýà {
î~ Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
à7÷’|¿á÷’$¶áq ¥‘2à7Åýàõ÷’„/6G7µ•ÄĆ ¥‘c¥‘jýàqTÅõÊõ®Î$Åõ,Êõ”Åõ,Ðõ
Ù›ÒH<ÐõlÔ÷<Ô÷ØÞ$Ü÷#üþõô¼þõˆßÄË÷%L†øæ7Œ†ø,�ø
Ùæ72<�øüáõÁ Œà7æ7¨ø ¡øüãôÅûüºõî¦7$öôëÐ,ìô›Ò$¾õ™Òyýàà7îæ7нÒî?ˆqAˆ®ÎÁðš�ØÞvˆßT†œýàÈ
 ‚”   †”  lˆ”ýàÔˆ”T–”Ć,d–”üˆ”,|£”
Ýà7HŒ£”ü†”< )#• • – »8Fu\»ŸÅp@ HTæ
™"³½›ÒÝŸzƒ Á”  T’—<’—
Þ¡ š—
 .üé”ļé”
Pû 
¬‰—  +LÁ— æ7üÌ”‰ Œû æ7  Û—üƒ’ØÉ Ù   Ú—æ7€Jüþ“Ý
ŒŒÑ�õ€‘…€³uÈxc¨”û æ7T«’¦7$œ’³½ ¢’û Û¬³½ ® ›ÒTà7…ýà£KKÃ
Mã
DEhcí ªkîû —û �æ7yú ±¢»GkƨŸï¤ Çõ 0«¡³½Uæ7r
 ôœ   øœ  Túœÿœ®Î$úœ ,ÿœÔøœ )#ÝŸ ".
™"—™ÒÝŸœU ^ ‘�  TâŸ<âŸ
Þ¡ êŸ-ü¹�ļ¹�
P¥§¬ÙŸ*L‘ 
æ7Œ‘ ,› †œ
- <› üœ�‘ Œ¥§æ7 ³  ¬ ü¿šô …5üðœÃ ŒŒÑ�õ€‘…€³uÈxc¨”¥§æ7TüšëÐ\æšÓ¦ 󚥧ÛnÓ¦bÙ¦™ÒRKKÃ
Mã
DEhcí ªk¯¥§™æ7|½Ò›˜±š»O®ÎÞͦ»Ÿ§IÔ§†œàª�Ó¦| ô°  ø° lú°
ýàÔú°Tˆ±Ć
, dˆ±üú°,|•±¨Ÿ AŒ•±üø°< )#ÝŸ#/º¤ ÆEN ³± ø>ø°=

ž$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ã–Ùy} ‰ ›üø°=
lã!+
�´ Tˆ´<ˆ´õ : !?´± [Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Œçü®‹s
¡$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
æ¢ü®È° Û Ñ´ æ7 ü߱ļ߱«¡¬ÿ³
&L·´æ7ü±‰ Œû æ7ü¿±� Ö¿æ¢ü®«³¿ Ò´üØ®úàð
/"æ7 ‹jüð°â6=Dȱ±¬‡¯¦7$ø®³½ þ®ã­•¢˜¢™¢lš¢ˆ›¢œ¢[�¢ˆe0<#˜È°ãñª®c³½ò® u›Ò¦à7×ýàõó5È°ãŸæ¢Ü�¤!û ã�æ7l‘±»Ž Ž ¹
ç Ɔ¨Ÿd¤ C¤®áõ ï«±ïæ7î«¡Ëãü³½!æ7  Œº  �º T’º—º®Î$’º,—ºÔ�º )#ÝŸ".ͦ‹DM ©º Ø@�º 
ž$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
•ª–×w{ ‡ ™Ü�º l•ª * †½ Tþ¼<þ¼Ÿ§:!Aªº
[Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Œçòºˆs
¡$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
·©òº¼¼
Ûþ Ͻ  üպļպԧ¬õ¼
 &L­½æ7Œ­½,·½†œ-
 <·½ü¸º‘ Œ¥§æ7
üµº• Ö¿·©òº ÌÔà н Ƚ
üº·–
%
P
a
‘WüˆºÈV]d祽¬þ·ëÐ\è·Ó¦ õ·•ª�•¢˜¢™¢lš¢ˆ›¢œ¢[�¢ˆe0<#˜¼¼•ª º€Ó¦ÕÙ¦’™ÒÅó5 ¼¼)•ª®·©Ìª<¥§+•ª�æ7½Ò5†§û±ý»�Ž ¥
¹- Ë
®ÎrͦOšºîŸ§ÿŸ½üÔ§à†œ§ª•ªÓ¦6
 Ô   lçÂýàÔçÂTõÂĆ, dõÂüçÂ,|‚èŸA Œ‚Ã<¡Ã  üØÂtY6)#ÝŸ\¶Ã ,TœÆ<œÆõ  ¤Æ
 $üóÃļóë¡
¬“Æ  &LËÆ æ7üÖÉ Œû æ7  åÆ äÆæ7üŽÀ×$4 ˜3üЕ
æ¢TŒÂ¦7$ÆÀ¥<ÔÀºî È• • – »8Fu\»Ÿ ³4û Û èÀãO›Òóà7$ýàB Èå�¤pû _æ7W»captureÁ±z»ËFĆ£¨Ÿ�­È>õ «¡ðæ7Š È‘
 ®Ì   T´Ì¹Ì®Î$´Ì ,¹Ì<ÀÌ  ü²Ì#[6)#ÝŸ\ÉÌ ,T¥Ï<¥Ïõ  ­Ï $üüÌļüÌ«¡¬œÏ &LÔÏ
æ7ŒÔÏ,Þφœ
- <ÞÏüßÌ‘ Œû æ7 öÏ ïÏ ü²ÉÄ õÏ �6üªÌÌ æ¢TÌËëÐ\øÉ È<�Ê ºî È¸ÈçÈ ¡Êã™Òè ÈÇ�¤Rû Aæ7#½ÒB¼zßÈ}±k»u®Î`°Îõ ð«¡Í†œ”�¤D È+ ÇÕ '/lÚÕ ýàÔÚÕTèÕĆ ,dèÕüÚÕ,|õÕ¨ŸAŒõÕ<”Ö 
üËÕtY
6)#ÝŸ\©Ö,øBËÕu
¤®H# / AüËÕu
lã!+
›Ù T“Ù<“Ùõ : !C¿Ö [È°ß «± ,ù ÜÙ æ7 üêÖļêÖ«¡¬ŠÙ
&LÂÙæ7üÍÖ‰ Œû æ7üÊÖ� Ö¿æ¢ü®«³¿ ÝÙÓæ7
üäÒùô & £VüÃÕš†�”±±¬ôÔ¦7$£Ó È<±Óºî È¸ÈÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
çÈü® ÅÓãî±µª®?›Ò’à7Ãýàá È„ó5tÈ°}ãæ¢ð�¤5û $ãñæ7%€‡ßȱ»»«Ž  ¹‰
õ Ɖ¨Ÿg†×$¤®ùõ a«±æ7«¡íæ7ã$ È+ òß '/Tøßýß®Î$øß,ýß<„à üöß#[6)#ÝŸ\�à,øDöß$
¤®H# / Aüöß$ lã!+ õâ Tíâ<íâõ :!E™à
[È°ß «±
,ù ¾ã  üÄàļÄà«¡¬äâ
 &Lœãæ7Œœã,¦ã†œ-
 <¦ãü§à‘ Œû æ7
ü¤à• Ö¿æ¢ü® ÌÔà ¿ã ·ã
üÙÜæ%6
G
©Wüîßѧ®µ9±±¬…ßëÐ\¦Ý È<»ÝµÎ È¸È”× ÏÝㄱµÔª®™Òd ÈCó53È°<ãÂ梎�¤þû íã°æ7ؽÒ÷HO½ßÈÀ±±»7Ž Æ
¹O ›
®Î(•á㤮¸õ  «±Æ«¡°†œw�¤êãå Èì
 Óÿ  ×ÿ læÿýàÔæÿTôÿĆ, dôÿüæÿ,|�€¨ŸA Œ�€ ‘€ L €
æ7Œ €,ª€½Ý
,  <ª€ü×ÿe   &.:
™"³½›Ò‘Þ2a j »€ TŒƒ<Œƒõ  ”ƒ  $üã€Ä¼ã€«¡ ¬ƒƒ  &L»ƒ
æ7üÆ€‰ Œû æ7 
Õƒü¦ý¯Ì Ü ì ü
 Ôƒæ7´jüÏÿ†æ¢TÐý¦7$Áý³½ Çýã̳½®¬æà›Òbà7“ý౑Þ*½ÒH�¤Tû Cæ7;¿Æ†±ˆ»V4 ƨŸì½Ý¡¢æ�õ ñ«¡Î›Ò(³½/æ7)  �‹
  ‘‹
 T“‹˜‹®Î$“‹
,˜‹LŸ‹æ7ŒŸ‹,©‹½Ý-
<©‹ü‘‹  
(
™"Ó¦™Ò‘ÞÑM
V °‹
 T�Ž<�ŽŸ§ ‰Ž
#ü؋ļ؋ԧ
¬ø� %L°Ž æ7Œ°Ž,ºŽ†œ - <ºŽü»‹‘ Œ¥§æ7  ÒŽ ËŽ üªˆ¨ö
 ¹4ü‰‹É·©TéˆëÐ\ÓˆÓ¦ àˆ•ªMÓ¦AæìÁ™Ò1‘Þú½ÒªK¥§:æ7½Ò<¬w±y»Èð®Î¤½ÝkÜìKŸ§áÔ§¿†œ‡ª7Ó¦ í— '/ ñ— l€˜
ýàÔ€˜TŽ˜Ć
, dŽ˜ü€˜,|›˜¨Ÿ AŒ›˜ «˜ Lº˜ æ7Œº˜,Ę½Ý , <Ęüñ—e   &.:¢æ#R[ Õ˜ øFñ—f
¤®ž#
/
Aüñ—flã!+ ²› Tª›<ª›õ :
!GÖ˜[È°ß «±, ù ó› æ7 ü�™Ä¼�™«¡¬¡› &LÙ›æ7ü䘉 Œû æ7üá˜� Ö¿æ¢ü®«³¿ ô›ü£•Ñàð&7HYDæ7
¿Œüé—‹¨¯:±±¬Ô•¦7$Å•³½ Ë•ãG±µ¸ª®I³½)¬æ[›ÒÝà7ýà,‘Þ¥½ÒÃó5CÈ°LãÒ梿�¤û óãÀæ7ôO|ƒË±Í»Ž ƹOÏ
ĆÔ¨Ÿ²½Ýg¢æG¤®Æõ .«±Ôæ7Ý«¡ºãë›Ò³½æ7ÿ Ø£  Ü£ Tޣ㣮Î$Þ£,ã£Lê£
æ7Œê£,ô£½Ý
- <ô£üÜ£   (ÜìÂ>G û£ øHÜ£!
šºx" . @üÜ£!
l•ª!+
ئ TЦ<ЦŸ§: !Iü£ [¼¼Þ Ÿ½ ,÷ ¡§  ü§¤Ä¼§¤Ô§¬Ç¦
&Lÿ¦æ7Œÿ¦,‰§†œ- 
<‰§üŠ¤‘ Œ¥§æ7ü‡¤• Ö¿·©òºÌÔà ¢§ š§üØ Ê%HYÅWüԣΦ­´8¥½¬ž¡ëÐ\ˆ¡Ó¦ •¡•ª¿ÆÁ º!Ó¦³æì3™Ò£‘Þl½Ò‹ó51¼¼:•ªÀ·©�ªý¥§ì•ª®æ7×½ÒöG`¼±¾»Ž  ¹?
Œ ®Îb½Ý)Üì šº®Ÿ§Ÿ½¼Ô§¨†œoªâ•ªÝÓ¦öüŽá d“á
Íà7æ7�“”’•ˆ–—“˜ˆÐKZ^÷æ7“
”æ7«‡$Žál á±‡ Ü“á¶áÐüêßÌŒŒÑ�õ€‘…€³uÈxc¨”à7à†Ì“à¦7$Šà nÔ†)ü‰å dŽå
Íà7æ7�“”’•ˆ–—“˜ˆÐKZ^÷’æ7
—߉æ7$‰ål›åè‰ ÜŽå±åÒüåãÌŒŒÑ�õ€‘…€³uÈxc¨”à7—‰ÌŽä¦7$…ä n‹‰)Ö† ŒÈ†Ô³4ц&()Áç» ŒÙ»Õ³4â»&()Á݉ ŒÏ‰Ö³4؉&()Á$™X£Xæü”W� ú>L®W¸�D¡W 1$¹YÃYçü¶X�ú>,ÒXú>$ÉX -$—[¤”[®[èüÖYØú>$õYú>$åY «1”–[÷9$ß^üØ^.$’_  ’_
™"¤² ú>7?œ_éüÁ[ÛüÇ^Uü²\ê³4è[†�dÕ[¤² ã[†�¦ ú>Œß^„�¨0±3Ä Ë^€ú�ß$´e¾eðüÿd? ­9„™eñ‘DŒe 0�fñüÄe=­9dàe­9$×e )#­92Æfòü‡f?­9$­f­9$–f÷ )#­93<šh  šh
™"¤² ­97?§hóüÌfÛ³4ófõ“dàf¤² îfó“‚± M铬ü—
Mä—

¹à7æ7‚à7æ7Ã5°îºî³4$´
)#¡•üº
)[ê
�üÜ Ž¦7$ˆ
æ7$ü … .••©ü¾
%ü¾
"

›Ò“Þ á
-ã
‚©›Ò½
¡•¿‘Þ »
® ÝÌ–� ¾ �‹3‘3”+Ã26‹3=D É �‹3‘3—+Ã26‘3=D2D\x€×öíýDÏÙ‡ýPƒçlðï…Ñ$ÿŒ†ZeroFromÁDÕ
ˆ˘4ˆü²¬ü™jg 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)),ÁüŒif 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.Á¡úü¥fc Succinctly, this allows one to "erase" static lifetimes and turn them into dynamic ones, similarlyÁüŒTQ to how `dyn` allows one to "erase" static types and turn them into dynamic ones.ÁáúüåXU Most of the time the yokeable `Y` type will be some kind of zero-copy deserializableÁü¾ UR 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).Á¦ úüª da 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Áüñ
pm lifetime of the borrow used during [`.get()`](Yoke::get). This is entirely safe since the `Cow` borrows fromÁüâro the cart type `C`, which cannot be interfered with as long as the `Yoke` is borrowed by [`.get()`](Yoke::get).ÁüÕif [`.get()`](Yoke::get) protects access by essentially reifying the erased lifetime to a safe local oneÁœ¿ when necessary.ÁÓúü×74 See the documentation of [`Yoke`] for more details.Á2D\x€×öíÍýÎÙ‡ýßPƒçÎï…ÑÍŒ†˘Å
ˆ˘Ø4ˆFIL¤ÔüË85 Types for optional pointers with niche optimization.Á„úüˆNK The main type is [`CartableOptionPointer`], which is like `Option<Rc>` butÁü×MJ with a niche so that the resulting `Yoke` has a niche. The following fourÁü¥74 types can be stored in the `CartableOptionPointer`:ÁÝú\á 1. `&T`Á|í 2. `Box<T>`Átý 3. `Rc<T>`Á|Œ 4. `Arc<T>`Áœúü OL These four types implement the sealed unsafe trait [`CartablePointerLike`].ÁüðKH In addition, all except `Box<T>` impl [`CloneableCartablePointerLike`],Áü¼@= which allows [`CartableOptionPointer`] to implement `Clone`.ÁdÜ ‰çl‰ï…»8\Û• »8– §<÷‰ StableDerefÁ\˜É4� 
¤‚€ÌÍo”ìOü„8ü‘ "d” ö=¥  Íì’4 ¡ 
’4 
¤º DÁ  Ã4ƒ \Ù<Ý „ë4õ  Îìœë رر|†ü�:ü˜85 An object fully representable by a non-null pointer.ÁÑúdÕ # SafetyÁâú¼æ Implementer safety:Áþúü‚`] 1. `into_raw` transfers ownership of the values referenced by [`StableDeref`] to the caller,Áüã(% if there is ownership to transferÁüŒWT 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.ÁéúüíXU Note: the pointer `NonNull<Self::Raw>` may or may not be aligned and it should neverÁüÆVS be dereferenced. Rust allows unaligned pointers; see [`std::ptr::read_unaligned`].Áœ®رü�Øà±\à à±4Ñر7¼¸,˸#رI¼¸>˸5Íìà±Lº”¹DºüÞDA The raw type used for [`Self::into_raw`] and [`Self::drop_raw`].Á4­¿ü�(üÉ.+ Converts this pointer-like into a pointer.Á4‚D’౉‰§‹‰ ïíe¼îËè¿*œ¹
à±$›üÃ0ü½74 Drops any memory associated with this pointer-like.Áùúd�é±’ú”š Caller safety:Á±úü¹EB 1. The pointer MUST have been returned by this impl's `into_raw`.Áüƒ(% 2. The pointer MUST NOT be dangling.Á4¶DÍ­»³4
౉ <Öü÷Bü÷?< An object that implements [`CartablePointerLike`] that alsoÁü·EB supports cloning without changing the address of referenced data.Áýúd�鱎ú¼’Š²ªúü®KH 1. `addref_raw` must create a new owner such that an additional call toÁüú41 `drop_raw` does not create a dangling pointerÁü¯GD 2. `addref_raw` must not change the address of any referenced data.Áäˆرü÷é౜¦ر(ÎÂر4ÎÂ)ü¬2ìÀ Clones this pointer-like.Áâúdêé±ûú”ƒñ»šúü¢E™¼üì(è¼4ŸT¶­»³4
౉ <ÁäâÔ¥Íì«1 ë¥1ç
üÞ0Ô¥�Å î¥1ê"$D• š «1ü¶ D¹ ¥1€?
Ô«1lü„!(DŽ!€?³4
Ô«1Ç?½üÏ"9Ô¥�Å ß"¥1  Û"ü�#*T§#€?³4
Ô«1Ç? üÌLB”""Íìƒ2 ÑLƒ2œúLË1#$%äãM$ñ
É2üØ#Tæè3’4NN
Q’45üæ0¥SSÔ° ë‚Ø<îè3TUê!ë!U \�4¢RR’4¬À,ÃÉ Éè3 É’4R ÉR
U’4$Êü©3¥WWÔ° ®‚Ø<±è3X÷!Xüñ!LôÊ Êè3 Ê’4V þV
X’4$ƒüê/¥ZZÔ° ï‚Ø<òè3[�"[”®$±Ë Ëè3³4Y Y
[’4$»|¾\ÂýD×Ù\]‡ýP\]ƒêhdñÃÛ\_µ ÿ“\`|ÐT$åŒì2 "܆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ˆq$•& ™8$›'Ÿ8°4¡(©8$¬ ± Ì8ˆq$¿+ Ö × Þ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×
Ú8,Û8$á8æ
é8,ê8$ð'ô8°4ö8 “8® |– ¥ ª8$¦(¬8$¯'³8°4µ ¼ ã8"4¦ ­ Ù8¿8µ Ã& Æ
È8,É8$Ï'Ó8°4Õ Ü Þ ó ß8$à8å
è8,é8$ï ô8castÁ$õ ù ú% û8�8 ‘ “8êhd•'¡8æ £ ¦ «8$§% ¬8µ ¾'Á8readÁ$Ã Ç Ë8µ È8"4î8 õ8Å $ø ü �8÷$ý& �8$ƒ'‡8°4‰(‘8$” ™ µ8 debug_assertÁd§ ³ ´ ã8š<µ'¼ ¾8$¿'Ã8°4Å Ë Ì ÍÏ8š<Ò'Ù Û8$Ü à á â% ä8ò8µ ö ú ü8÷$ý8‚
…8,†8$Œ'�8°4’8™
œ8,�8$£% §8µ8 ¹ »8êhd½'É8æ Ë Î Ó8÷$Ï% Ô8"4“ š «8µ œ'Ÿ8‚í$¡ ¥ ©8µ ¦8 À8Ñ là Ð8— Ñ Ò Ó æ Ô:ÔÕ8Ø8$Ü$ à8± â& ã8— å8$,ð8— ‚& ƒ:7<… �8
� ’:Í “ •8†4— � ² ž:Í Ÿ8¢8$¦'ª8°4¬$ ³ ½ �8,Ë'Ð8¾
,Ò'×8Î
´Ù ï ÷8$ð$ ô8± ö% ˆü˜MÔe¥fef�Å ¨«1<«gÙ«1g¤µ¡6h³´µÛÜÝÞßµ³´¤df¹\ì4ñddÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ«1ÔÛüÕuÔjè kø mkmjÍìø6åÍìý6‰ø6<élÙø6l¤óý6<�nÙý6n¤—
”­K€…¾
,Ìx€†ýDÞÙ€‡‡ýP€‡ƒ»8\ú• €ˆ»8– €ˆêhd–ÃÛ€‰r,³é!€ŠÑ®\Ò€‹œÏñóÌ–åü�/×dÅÉ|×»Ì쑼‹m„¨^ü¾OüÅ+üï;8 A Cow-like borrowed object "yoked" to its backing data.Á«úü¯GD This allows things like zero copy deserialized data to carry aroundÁü÷QN shared references to their backing buffer, by "erasing" their static lifetimeÁüÉ2/ and turning it into a dynamically managed one.Áüúü€C@ `Y` (the [`Yokeable`]) is the object containing the references,ÁüÄFC and will typically be of the form `Foo<'static>`. The `'static` isÁü‹ RO not the actual lifetime of the data, rather it is a convenient way to mark theÁüÞ (% erased lifetime and make it dynamic.Á‡
úü‹
ZW `C` is the "cart", which `Y` may contain references to. After the yoke is constructed,Áüæ
YV the cart serves little purpose except to guarantee that `Y`'s references remain validÁüÀ da 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ÁüŠ
YV 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ÿ¢ü®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ÁœÖÒ¦êúüîli 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ÁôúüøQN 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;Áü£74 # fn load_from_cache(_filename: &str) -> Rc<[u8]> {ÁüÛ! # // dummy implementationÁüýKH # Rc::new([0x5, 0, 0, 0, 0, 0, 0, 0, 0x68, 0x65, 0x6c, 0x6c, 0x6f])Á<É # }ÁÑúüÕIF fn load_object(filename: &str) -> Yoke<Cow<'static, str>, Rc<[u8]>> {ÁüŸ52 let rc: Rc<[u8]> = load_from_cache(filename);ÁüÕOL Yoke::<Cow<'static, str>, Rc<[u8]>>::attach_to_cart(rc, |data: &[u8]| {Áü¥52 // essentially forcing a #[serde(borrow)]ÁüÛ>; Cow::Borrowed(bincode::deserialize(data).unwrap())ÁTš })Á,¥ }Á«úü¯/, let yoke = load_object("filename.bincode");Áüß'$ assert_eq!(&**yoke.get(), "hello");Áü‡52 assert!(matches!(yoke.get(), &Cow::Borrowed(_)));Á<½ ```Á$Ъ�”���Íìà7 ÕÍìæ7 îŽÙà7Ž¤Ø¦7³uÈxc¨”�‘LNÜOQüñDñ€ŒŒýà<ñ"$ñ"€ŒŒæ7üÿ#“ª“”•“•Ë› „$Û› �$”Ùà7”¤‡$¿cæ7„ $–¿cà7–Û„�%¦7—Àc—jl‹$uwà$ü™%Dœ%ÌÍΠ̦7 Í c cˆ¢cµ
 `£c¸D `àB¤GS
ΈD’  %’
—à7æ7$¡%±úgüù&Œª™”šš™Ë› þ&Û› �'›Ùà7›¤³'œÄcà7œÛ”ò'¦7�Åc�[]`b·'Ñ'üŒ(D�(ÏÐÑ Ï¦7 Рc cˆ¢cµ
 `£c¸D `àB¤GS
шD˜ “(˜
�à7æ7$”(±»iü‹)zªŸ” Ÿ Ë› �)Û› “)¡Ùà7¡¤¼)¢µßà7¢ÛÇ£Lû)¦7£·ß£acfhÀ)Ú)üŒ*"�*ÒÓ Ò¦7 Ó¦7ž ’*ž
£à7æ7$“*¹
ÊjüÜ*lª¥”¦¦¥Ë› á*Û› ä*§Ùà7§¤†+¨™à7¨ÛÅ+¦7PRUWŠ+¤+üÎ+|ªª”««ªË› Ó+Û› Ö+¬Ùà7¬¤€,­íßà7­Û˜§T¿,¦7®ïß®acfh„,ž,üÑ,B\Ô,ÔÕ Ô¦7 Õ¦7ÒØ© à,©
®à7æ7$á,¹
ŽlüË-nª°”±±°Ë› Ð-Û› Ó-²Ùà7²¤ö-³ºà7³Ûµ.¦7´»´[]`bú-”.üÀ.2Ã.Ö× Ö¦7 צ7—Ù¯ Ç.¯
´à7æ7$È.¹
™müŸ<aª”¸¸Ë› ¤<Û› ½<·Ùà7·¤§<æ7\À<“Þ<ø<¦7¹¼ÀÂQS«<\^ü¡R£ü‡=EB Construct a [`Yoke`] by yokeing an object to a cart in a closure.ÁÑ=úüÙ=QN 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.Áð>úüø>RO See also [`Yoke::try_attach_to_cart()`] to return a `Result` from the closure.ÁÏ?úü×?UR Call sites for this function may not compile pre-1.61; if this still happens, useÁü±@41 [`Yoke::attach_to_cart_badly()`] and file a bug.Áê@útò@ # ExamplesÁ…Aú<�A•š¬™A�“´³A­“ÜÎAÌ“üîA7ñ“üªB!²”üÐBKÝ”< C±•¬Cúü´CIΕü‚D5¡–ü¼DOà–ü�E5¹—üÊE>ø—T�F¿˜,œFÒ˜¦Fúü®FB? let yoke: Yoke<Cow<str>, _> = load_object("filename.bincode");ÁüõF'¦™ü¡G5×™<ÛG•šçGúüïG;8 Write the number of consumed bytes to a local variable:Á¯Hú<·H•š¬ÃH�“´ÝH­“ÜøHÌ“ü˜I7ñ“üÔI!²”üúI?< # Rc::new([0x5, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0, 0, 0])Á<¾J±•ÊJúœÒJ fn load_object(Á¼êJ filename: &str,Áü†K52 ) -> (Yoke<Cow<'static, str>, Rc<[u8]>>, usize) {ÁüÀK5¡–üúK$! let mut bytes_remaining = 0;Áü£L30 let bytes_remaining = &mut bytes_remaining;ÁüÛLGD let yoke = Yoke::<Cow<'static, str>, Rc<[u8]>>::attach_to_cart(Á|§M rc,ÁÜ»M |data: &[u8]| {ÁüÛMEB let mut d = postcard::Deserializer::from_bytes(data);Áü¥NEB let output = serde::Deserialize::deserialize(&mut d);ÁüïN?< *bytes_remaining = d.finalize().unwrap().len();Áü³O.+ Cow::Borrowed(output.unwrap())ÁtæO },ÁTùO );ÁüˆP  (yoke, *bytes_remaining)Á,­PÒ˜·Púü¿PC@ let (yoke, bytes_remaining) = load_object("filename.postcard");Áü‡Q'¦™ü³Q5×™üíQ# assert_eq!(bytes_remaining, 3);Á<•R•št¨Ræ7¤²¦7µ—ººµ…þ ·R»–"¤² »“ÞüÒUJ»¤²Ú½˜"à7»Ûä€Vë«<¼V
¹à7æ7¤²…Ào±Êoz|ÖUüä\Ôü©ZRO Construct a [`Yoke`] by yokeing an object to a cart. If an error occurs in theÁü€[@= deserializer function, the error is passed up to the caller.ÁÅ[úüÍ[U¥®ü§\85 [`Yoke::try_attach_to_cart_badly()`] and file a bug.Á”ë\æ7³½ºçµ–½—¾¾½µÍìøä þ\Íì³½ �]¿–"³½ ¿“Þü»]U¿³½âÁ˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
à7¿Ûøäüé]'ë«<°^
¼à7æ7øä³½…u±uâäÞà¿]üÍcŽü¢b# Use [`Yoke::attach_to_cart()`].ÁÊbúüÒbda This was needed because the pre-1.61 compiler couldn't always handle the [`FnOnce`] trait bound.Ál»c¤Ôcæ7Á Á“Þà7ÁÛ¦7µµ
Àà7æ7…w±wŠdü¾f«ü�e'$ Use [`Yoke::try_attach_to_cart()`].Á»eúüÃedˆÃl¬fÄÅfæ7Ä Ä“ÞÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
à7ÄÛøäºçµ–Ãõ°Á Þf
Âà7æ7øä…x±!x!#‚güŸh+ªÆ”ÈÆÈË› ¤hÛ› ½hÇÙà7Ǥ§h¦7ÉËÌÍÐÔÙAC«hLNü×q;üÑh1. Obtain a valid reference to the yokeable dataÁ‡iúü�iMJ This essentially transforms the lifetime of the internal yokeable data toÁ
be valid.ÁüóiJG For example, if you're working with a `Yoke<Cow<'static, T>, C>`, thisÁüÂj# will return an `&'a Cow<'a, T>`Áêjúlòjò‘„kú\Œkû’¬œk�“´¶k­“ÜÑkÌ“üñk7ñ“ü­l!²”üÓlKÝ”<£m±•,¯m #Áü¹mKH # fn load_object(filename: &str) -> Yoke<Cow<'static, str>, Rc<[u8]>> {Áü‰n74 # let rc: Rc<[u8]> = load_from_cache(filename);ÁüÅnQN # Yoke::<Cow<'static, str>, Rc<[u8]>>::attach_to_cart(rc, |data: &[u8]| {Áü›o@= # Cow::Borrowed(bincode::deserialize(data).unwrap())Ádào # })Á<ño±•ýoúü…pC@ // load_object() defined in the example at the top of this pageÁüÍpBÔ±ü”q$! assert_eq!(yoke.get(), "hello");Á<½q•šÞqÊ Ê¦7 Êà7ÊÛÅâqÅ®Î$êqüµt üÂr(% Get a reference to the backing cart.Áïrúü÷rXU This can be useful when building caches, etc. However, if you plan to store the cartÁüÔs\Y separately from the yoke, read the note of caution below in [`Yoke::into_backing_cart`].Ád¼tØ Ø¦7 Øæ7Å ÉtÅ·Ï$Êtü¢�#üöt@= Get the backing cart by value, dropping the yokeable object.Á»uúüÃu]Z **Caution:** Calling this method could cause information saved in the yokeable object butÁü¥v[X not the cart to be lost. Use this method only if the yokeable object cannot contain itsÁ¤…w own information.Ážwúl¦wò‘¸wúüÀwYV Good example: the yokeable object is only a reference, so no information can be lost.Ážxú<¦x•šœ²x use yoke::Yoke;ÁÊxúüÒx&# let local_data = "foo".to_owned();ÁüýxKH let yoke = Yoke::<&'static str, Box<String>>::attach_to_zero_copy_cart(ÁìÍy Box::new(local_data),Á4ïy );Áüúy# assert_eq!(*yoke.get(), "foo");Á¢zúĪz // Get back the cartÁüÇz(% let cart = yoke.into_backing_cart();Áôôz assert_eq!(&*cart, "foo");Á<—{•š£{úü«{@= Bad example: information specified in `.with_mut()` is lost.Áð{ú<ø{•šÌ„| use std::borrow::Cow;Áœ¢|ì׺|úüÂ|&•Ø”í| let mut yoke =Áü„}IF Yoke::<Cow<'static, str>, Box<String>>::attach_to_zero_copy_cart(ÁüÒ}! Box::new(local_data),ÁTø}Žºü‡~" assert_eq!(yoke.get(), "foo");Á®~úü¶~  // Override data in the cartÁÌÛ~ yoke.with_mut(|cow| {Áüù~# let mut_str = cow.to_mut();ÁÄ¡ mut_str.clear();Áü¾  mut_str.push_str("bar");Á<ã });Áüï" assert_eq!(yoke.get(), "bar");Á–€úÄž€‡Úü»€(©Úüè€)& assert_eq!(&*cart, "foo"); // WHOOPS!Á<–�•šŒ©�¦7æ7ÅÅ
Ìà7æ7æyü��Lüå�74 Unsafe function for replacing the cart with anotherÁ¡‚úü©‚<9 This can be used for type-erasing the cart, for example.Áê‚údò‚鱃ƒúü‹ƒTQ - References from the yokeable `Y` should still be valid for the lifetime of theÁìäƒ returned cart type `C`.Á†„úüŽ„^[ For the purpose of determining this, `Yoke` guarantees that references from the YokeableÁüñ„b_ `Y` into the cart `C` will never be references into its stack data, only heap data protectedÁüØ…eb by `StableDeref`. This does not necessarily mean that `C` implements `StableDeref`, rather thatÁü†eb any data referenced by `Y` must be accessed through a `StableDeref` impl on something `C` owns.Á¬‡úü´‡gd Concretely, this means that if `C = Option<Rc<T>>`, `Y` may contain references to the `T` but notÁ¤ ˆ anything else.Áü¹ˆ[X - Lifetimes inside C must not be lengthened, even if they are themselves contravariant.Áü™‰XU I.e., if C contains an `fn
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äØ\°®ØÔ<À®±•<Ì®•š|ß®¦7³½±±ü¡Œ—�–ŽŒ�Žü”Û ï®ÁÁ ò®Íìü® õ®�Ùû �¤²¯�–"³½à7�Û• • – »8Fu\»Ÿ �³4üÓ¯��³½Êî˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
û �Ûü®üº°&
‹à7æ7û ³½ü®š±!šBEHKEH¶¯ׯüº·¿üØ´JG This is similar to [`Yoke::try_map_project`], however it does not moveÁü§µR…Ýþµúü†¶aïÝüì¶IÛÞ´Á·ÃàÓ¦¥½üº’¡“—”–•”’•“ü�á ß·¡á â·Íìòº å·–Ù¥§–¤©¸†Älʸ—–"Ó¦ ºà7—Û• • – »8Fu\»Ÿ —³4ü且—Ó¦ßó˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¥§—ÛòºüÒ¹&
‘à7æ7º¥§Ó¦òº$ï·±6 ,Ø·adgjdg­¸è¸üŽÀ³üÕ½PM This is similar to [`Yoke::map_project`], but it works around older versionsÁüª¾NK 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.Áü•À!¦7 Èœà7œÛ È• • – »8Fu\»Ÿ œ³4û œÛæ¢ü¡™¥š™šü”Û ·ÀÍì È ºÀ›Ùû ›¤¬Â
˜à7æ7û  È™£ßȦ£±û£^`Y[°ÂïÀü²ÉéüëÆWT This is similar to [`Yoke::map_project_cloned`], but it works around older versionsÁüÇÇN�öüšÈBéöáÈúüéÈDA See the docs of [`Yoke::map_project_cloned`] for how this works.Áü¹É(ž ž¦7 È¢ žà7¢Û È• • – »8Fu\»Ÿ ¢³4û ¢Ûæ¢ü¡Ÿ¥  Ÿ,âÉü”Û éÉÅú ìÉ¡Ùû ¡¤ìˆÄl�Ì
�à7æ7û  È$ÿÉßÈ©¦±Ȧnpdfhjð˨ÊüäÒÐüüÏTQ 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.ÁüëÒ%¦7 È¨à7¨Û È• • – »8Fu\»Ÿ ¨³4Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
û ¨Ûü®±±ü¡¤¥¥–¦¤¥¦ü”Û ‘ÓÅú ”Ó‰î —Ó§Ùû §¤ŸÕ
£à7æ7û  Èü®ôªßÈÿª±m«bdfhjl£ÕÌÓüÙ܆üãÙ[X This is similar t
the cart.Á‚æúüŠæ\Y If access to the old [`Yokeable`] `Y` is sufficient to produce the new [`Yokeable`] `P`,ÁüëæXU 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,ÁüŸî41 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úð¿˜,‰ñÒ˜“ñú,›ñªÌü¥ñ52 # 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­ý¦7³½æ¢°¡µ—µ°”Û »ýÁÁ ¾ý·Ùû ·¤ðý¸–"³½à7¸Û ¸“Þü‘þ‡¸³½”¢˜"û ¸ÛÜýþë«<¸ÿ
´à7æ7û ³½´± ´½¿ÁÃôý•þüªˆÐüÛƒYV 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`]).Áü„úü„…KH 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.Á¤±ˆÃàÓ¦·©°ºº¡»—¼º»¼°�á ͈¡á Ј½Ù¥§½¤‰‰¾–"Ó¦ ºà7¾Û ¾“Þüª‰Ž¾Ó¦”©˜"¥§¾ÛÜ�Š†ÄlÅŠë«<òŠ
¹à7æ7º¥§Ó¦$Úˆ±N·,ƈÜÞàâ�‰®‰ü£•·üØŽRO This is similar to [`Yoke::map_with_cart`], but it can also bubble up an errorÁ´¯�¸ãÊ�úüÒ�\¡�ü³�UR 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�“Îäü¢“)æäüГ85 ) -> Result<Yoke<P<'static>, Rc<[u8]>>, Utf8Error> {Áü�”0- y.try_map_with_cart(move |bytes, cart| {Áü”74 Ok((str::from_utf8(bytes)?, bytes.first()))ÁTþ”¿˜,�•Ò˜<—••šŒª•¦7³½±±°¡À—Á–ÂÂÀÁ°”Û ¼•ÁÁ ¿•‰î •ÃÙû Ã¤ÿ•Ä–"³½à7ÄÛ Ä“Þü –’ij½̱˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
û ÄÛü®üŒ—&ë«<Ò—
¿à7æ7û ³½ü®U¼±`¼ #&),ƒ–¤–üØ íüú›]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 prefer
úü¤
qn 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Áüô
da 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>`.Á·úü»LI This trait is also safe to implement on types that do not borrow memory.ÁˆúüŒQN There are further constraints on implementation safety on individual methods.ÁÞúäâ # Implementation exampleÁÿúüƒWT 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Áü»OL in case you have your own zero-copy abstractions you wish to make yokeable.Á‹ú\�û’Ì› # use yoke::Yokeable;ÁܵÌ“ÔÑ # use std::{mem, ptr};Á¤ìþúü��ûì¡Æû¼¿íû,×Ò˜Ýúüá30 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 {ÁüöA> unsafe { mem::transmute::<Self::Output, Self>(from) }ÁL¸ÔÚÂúüÆ/, fn transform_mut<F>(&'a mut self, f: F)Álö
whereÁü„63 F: 'static + FnOnce(&'a mut Self::Output),ÁL» {ÁüÅNK unsafe { f(mem::transmute::<&mut Self, &mut Self::Output>(self)) }ÁL”ÔÚ,žÒ˜<¤•šD½ÙÔÚÙÚرü¬¾1à±<ËÙر%Åàر1Åà*ÛÜÝÞßÛÜÝÞßÍìà±ÔÛ„±•áÔ¾�á«áÞÜßÝÆ|±üÙSP This type MUST be `Self` with the `'static` replaced with `'a`, i.e. `Self<'a>`Á4¶ÙÙü”+üÇPM This method must cast `self` between `&'a Self<'static>` and `&'a Self<'a>`.Áœúܤ # Implementation safetyÁÄúüÌRO If the invariants of [`Yokeable`] are being satisfied, the body of this methodÁü£XU should simply be `{ self }`, though it's acceptable to include additional assertionsÁ|€ if desired.ÁL— Ôà± Ô•áÙÙ
Üà±Ô$¥üŠ")üÅHE 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…#é±–#úüž#VS The returned value must be destroyed before the data `from` was borrowing from is.Áù#úÜ�$Éâ¡$úü©$RO A safe implementation of this method must be equivalent to a transmute betweenÁü€%" `Self<'a>` and `Self<'static>`Á$±%•áà±ÙÙ
Þà±Ô÷$¶%ü©K¿üØ%XU 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?ÁÎ(úüÖ(PM Typically covariant lifetimes become invariant when hidden behind an `&mut`,Áü«)LI which is why the implementation of this method cannot just be `f(self)`.Áüü)gd The reason behind this is that while _reading_ a covariant lifetime that has been cast to a shorterÁüè*XU 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,E0521Áܺ-Ì“ÌÚ-º×„ø-
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));Á,í/Ò˜<÷/•šƒ0úü‹0da 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ÁüÙ1fc 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_ --Áü§3jg `f` does not contain any borrowed references, and while we give it `Self<'a>` (which contains borrowedÁü–42/ data), that borrowed data is known to be validÁÍ4úüÕ4ZW Note that the `for<'b>` is also necessary, otherwise the following code would compile:Á´5úô¼5ÙòÜß5Ì“Ìÿ5º×œ�6¤õ,µ6ªÌü¿6*�Фî6þú„‡7
num: u8,ÁÌœ7 cow: Cow<'a, u8>,Á,º7Ò˜Ä7úüÌ7/, fn unsound<'a>(bar: &'a mut Bar<'static>) {Áü€8HE bar.transform_m
öûˆ˘4öûˆ\Ϥ|à‘„öhüŒY|²JüÄĪý”þþýË› ÉÛ› ÌÿÙà7ÿ¤ç€
à7€Û€“Þü¦"Ý«\Ñé!æ7,ßë«<€¦7��„†ë…üÜ 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.Á²úüºYV 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:ÁÔú<Ü•šÌèýÛœ†ìמúü¦KH let yoke = Yoke::<Cow<'static, str>, String>::attach_to_zero_copy_cart(ÁÔö "demo".to_owned(),Á4• ¿Ù  úü¨ # assert_eq!("demo", yoke.get());Á<Ð •šÄã æ7¦7üü
�à7æ7…ŽÊº
�<closure_kind>Á‚<closure_signature>Á‚<upvars>Á‚‚�¡•¬ÂÌ\â)Ì)Ì;Ì;ÌÌŽDŸ”ËUÌüåI#ü­GEB A type with similar semantics as `Option<C<T>>` but with a niche.ÁóGúü÷GJG 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”ŠŠçÈ †J÷Èœ–JË1HíyœbŠLt‹Œ()+´’L,’L‰‰ñAÌ®LL®L‰‰åB7 7 ”ŽŽçÈ�¿cƒ2†J÷È�¿cŸB7 Ë1�Àc�ÃÅ7 7 ÚÛÜ ÚË1 Û c cˆ¢cµ
 `£c¸D `àB¤GS
܈D�ÝI�
�ƒ27 ±7 ÜœüÊRO A cart that can be one type or the other. Enables ergonomic polymorphic carts.Á�úü¡TQ `EitherCart` enables yokes originating from different data sources and thereforeÁüöUR having different cart types to be merged into the same yoke type, but still beingÁüÌ85 able to recover the original cart type if necessary.Á…úü‰OL All relevant Cart traits are implemented for `EitherCart`, and carts can beÁüÙ&# safely wrapped in an `EitherCart`.Á€úü„EB Also see [`Yoke::erase_box_cart()`](crate::Yoke::erase_box_cart).ÁÊútÎͯÝú<á•š¤é¡§üþ! use yoke::either::EitherCart;Áœ ì×´úü¸)& let y1: Yoke<&'static str, Rc<str>> =ÁüâOL 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");Á• úü™ MJ type CombinedYoke<'a> = Yoke<&'static str, EitherCart<Rc<str>, &'a str>>;Áç úüë QN // Both yokes can be combined into a single yoke type despite different cartsÁü½
63 let y3: CombinedYoke = y1.wrap_cart_in_either_a();Áüô
63 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");Áž úü¢ QN // The resulting yoke is cloneable if both cart types implement CloneableCartÁÄô  let y5 = y4.clone();Áü�
2/ assert_eq!(*y5.get(), "borrowed hello world");Á<À
•šT¥º ‘à ’’‘ÌÒ°ëÒ´Ã2ÐKZ^÷“”–—”•‹3Ã2—˜‘3Ã2LNQSGËGË��
”‹3‘3GËGË‹3Ã2��ï¹À��‹3™Ë™Ë��
—‹3‘3™Ë™Ë‘3Ã2��àºË��‘3 ) ) º šà ›š›ÌÒ|ëÒ{Ø‹3
°Ø‘3
´Ã2œÙœ´·»¾ ) )Ý ÝÃ2Ã2™
Ñ
™
œ‹3‘3 )®*®*!º žà ŸžŸÌÒ^ëÒ]Ã2knru®*®*!º ¡à ¢¡¢ÌÒ½ëÒ¼µß‹3‹3 °µß‘3‘3 ´Ã2£·ß£þ®*®*Þß ÞÃ2 ßÃ2  Ø
 
£‹3‘3®*¹
®*~.~."º ¥Ã ¦¥¦ÌÒ¿ëÒ¾™‹3 °™‘3 ´Ã2§›§÷úþ~.~.~.à àÃ2³4¤ ã
¤
§‹3‘3~.Á.Á.#º ©Ã ªª©ÌÒ»ëÒº¿c‹3
°¿c‘3
´Ã2«Àc«óöúýÁ.Á.áâã áÃ2 â c cˆ¢cµ
 `£c¸D `àB¤GS
ãˆD¨
ç
¨
«‹3‘3Á.±Á.øÆ$Ô­­³4®¯°±²ÛÜÝÞß±¯°²ÒXù0þ¬¬³4øÊ$HÍä ä³4 ä³4Ô۬׬
¯Ô Øø¦(x©³4éŬ¬
°Ô&8ø†* �éų4¬¬
±Ôˆq}8øèthë Ô³4Òr³4¬—³³¬ÍìÒrùÒr8­´–"Òr ´éÅø·$´Òr±È˜"³4à¿
²ÔÒr „±+9np»øÆ$ÔÃ4·¸¹º»ÛÜÝÞ߸º»¹ÒXù0þµµÃ4øÊ$HÍå åÃ4 åÃ4ÔÛµ×µ
¸Ô Øø¦(x©Ã4Äʵµ
¹Ô:ø†* �ÄÊÃ4µµ
ºÔˆqa:øèthë ÔÃ4Òr³4µ—¼¼µ†Èù—È8­½–"Òr ½ÄÊø·$½Òr‚͘"³4à¿
»ÔÒr „±;ln»øÆ$Ô¿¿Ó4ÀÁÂÃÄÛÜÝÞßÃÁÄÂÒXù0þ¾¾Ó4øÊ$HÍæ æÓ4 æÓ4ÔÛ¾×¾
ÁÔ Øø¦(x©Ó4•Ï¾¾
ÂÔÜ;ø†* �•ÏÓ4¾¾
ÃÔˆq;<øèthë ÔÓ4Òr³4¾—Åž†Èù—È8­Æ–"Òr Æ•Ïø·$ÆÒrÓј"³4à¿
ÄÔÒr „±Ü<ln»øÆ$ÔÈÈã4ÉÊËÌÍÛÜÝÞßÌÊÍËÒXù0þÇÇã4øÊ$HÍç çã4 çã4ÔÛÇ×Ç
ÊÔ Øø¦(x©ã4æÓÇÇ
ËÔ¶=ø†* �æÓã4ÇÇ
ÌÔˆq>øèthë Ôã4Òr³4Ç—ÎÎdžÈù—È8­Ï–"Òr ÏæÓø·$ÏÒr¤Ö˜"³4à¿
ÍÔÒr „±¶>ln»øÆ$ ÔÑÑó4ÒÓÔÕÖÛÜÝÞßÔÓÕÖÒXù0þÐÐó4øÊ$HÍè èó4 èó4ÔÛÐ×Ð
ÓÔ Øø¦(x©ó4·ØÐÐ
ÔÔ�?ø†* �·Øó4ÐÐ
ÕÔˆqï?øèthë Ôó4Òr³4З××ІÈù—È8­Ø–"Òr Ø·Øø·$ØÒrõÚ˜"³4à¿
ÖÔÒr „±‘@ln»øÆ$
ÔÚÚƒ5ÛÜÝÞßÛÜÝÞßßÝÜÞÒXù0þÙÙƒ5øÊ$HÍé éƒ5 éƒ5ÔÛÙ×Ù
ÜÔ Øø¦(x©ƒ5ˆÝÙÙ
ÝÔnAø†* �ˆÝƒ5ÙÙ
ÞÔˆqÍAøèthë Ôƒ5Òr³4Ù—ààÙ†Èù—È8­á–"Òr áˆÝø·$áÒrÆߘ"³4à¿
ßÔÒr „±oBln»øÆ$ Ôãã“5äåæçèÛÜÝÞßèæçåÒXù0þââ“5øÊ$HÍê ê“5 ê“5ÔÛâ×â
Reference in New Issue Copy Permalink