aamos-ledger-rust/target/debug/deps/libyoke-f8bf9e5b8bbb2034.rmeta

rust
ôÚ#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁstable_deref_traitÁ½ÊTýö÷n˜TóQ-á†-771635b0451f799dÁ¤°ð¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁyoke_deriveÁ×ã„Ô„ýT·+CIƒ•sÙ-ad663b8de2c8c776ÁzerofromÁ/ŽErÅÉŽV 7Í�-92c585200eab8211Ázerofrom_deriveÁŸæþÇŽá2?M¥e ’(-abe85a41d9dcc735Á‰¤,Ì»¤Œ«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¥V¶DY¥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Ÿpp°vutilsÁ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_}öáf@”Œ"Ë1ØË1ïË1ÌìË1� Ë1Ø�“”’•ˆ–—“˜ˆö\ŸÑ€ƒ4Ôº	Ã	ÐìÃ2µßÃ2Ã2™Ã2¿cÃ2é!Ã2Ã2ïÃ2é!KKÃ
Mã
D§ñù›K¨îé¥ö!è3Œ"è3ÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÔÙÛ¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙ«1ÔÙèøÔÙ«1ŸÔ¿cŒŒÑ�õ€‘…€ †|À§M
ª”Ä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íßºÄœ4
"„œ
ñ’43D³üóL	K’4¾Åü¾‡Pè3$ä’44ÖÑÛÑÛMaybeUninitÁÓÛuninitÁÝÔÛ»ÝÍõƒ«%9’4ú’4ùã
i˜üŠÇ!D¢Ç	
%¼ŠÇ
Pà74GªÇ$¿Ç		Û¼æ7ü›Æ³	Œà7Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙæ7ÍÇ	ÔÇüåÅïãŒŒÑ�õ€‘…€ †|À§M
à7�@$ŒÆà7DüÅKKÃ
Mã
D§ñù›K¨îéà7�à7��@KõO¾Ö†	ŒÈ†Ô³4Ñ†&()Áç»	ŒÙ»Õ³4â»&()ÁÝ‰	ŒÏ‰Ö³4Ø‰&()Á¾	�‹3‘3”+Ã26‹3=DÉ	�‹3‘3—+Ã26‘3=D2D\x€×öíýDÏÙ‡ýPƒçlðï…Ñ$ÿŒ†ZeroFromÁDÕ
ˆ«E4ˆü²¬ü™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ƒçÍï…ÑÌŒ†«EÃ
ˆ«EÕ4ˆCFI¤ÔüË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”‰‰§‹‰ïíe¼îËè¿*’4¥		Íì’4¡
’4
¤ºDÁÃ4ƒ\Ù<Ý„ë4õÎìœëã^ã^|†Eü�:ü˜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Ñã^4Äe)Òe ã^CÄe8Òe/Íìë^Lº”fDºüÞDA The raw type used for [`Self::into_raw`] and [`Self::drop_raw`].Á4¿ü�(üÉ.+ Converts this pointer-like into a pointer.Á4‚D’ë^‰‰§‹‰ïíe¼îËè¿*œf
ë^$›üÃ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Íªh³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.Áäˆã^ü÷éë^œ¦ã^&Ãoã^0Ão%ü¬2ìÀ Clones this pointer-like.Áâúdêò^ûú”ƒëhšúü¢E“iüì(âi4ŸT¶ªh³4
ë^‰<ÁäâÔ¥Íì«1ë¥1ç
üÞ0Ô¥úqî¥1ê"$D• š «1ü¶ D¹ ¥1‰‰§‹‰ïíe¼îËè¿*«1
Ô«1$Â ü„!(DŽ!²s³4
Ô«1_pointerÁD—!üÏ"9Ô¥úqß"¥1  Û"ü�#*T§#²s³4
 Ô«1ÈsD²#üÌLB”"
ˆüØ#Tæè3’4NN
Q’4$ñüæ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\]ƒ†ƒdñÃÛ\_µÿ“\`|ÐU$åŒì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Å $�”§8thisÁ$•&™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×
Ú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†ƒd•'¡8æ	£¦«8$§%¬8µ¾'Á8readÁ$ÃÇË8µÈ8"4î8õ8Å $øü�8÷$ý&�8$ƒ'‡8°4‰(‘8$”™µ8debug_assertÁd§	³´ã8š<µ'¼¾8$¿'Ã8°4ÅËÌÍÏ8š<Ò'ÙÛ8$Üàáâ%ä8ò8µöúü8÷$ý8‚
…8,†8$Œ'�8°4’8™
œ8,�8$£%§8µ8¹»8†ƒd½'É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úq¨«1<«gÙ«1g¤µ¡6h³´µ¶ÛÜÝÞß¶µ³´¤df¹\ì4ñddÛ¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙ«1ÔÛüÕuÔjèkømkmjÍìø6åÍìý6‰ø6<élÙø6l¤óý6<�nÙý6
”K€…¾
,Ìx€†ýDÞÙ€‡‡ýP€‡ƒ»8\ú• €ˆ»8– €ˆ†ƒd–ÃÛ€‰r,³é!€Š®[\Ò€‹œÏñóÌ–åü�/×dÅÉ|×»Ìì‘¼‹l„¨]ü¾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ÞOü®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ÁœÖ±Sêúüî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 †|À§M
�‘LNÜOQüñDñ€ŒŒêA<ñ"$ñ"€ŒŒæ7üÿ#“ª“”•“•ûÈ„$‹É�$”Ùà7”¤‡$¿cæ7„ $–¿cà7–Û„�%¦7—Àc—jl‹$uwà$ü™%Dœ%ÌÍÎÌ¦7Í c cˆ¢cµ
 `£cbufÁ `àB¤GS
ÎÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
³4ŸÈŸÈ ÈErrorÁO˜éBL’ %’
—à7æ7$¡%±§%üù&Œª™”šš™ûÈþ&‹É�'›Ùà7›¤³'œÄcà7œÛ”ò'¦7�Åc�[]`b·'Ñ'üŒ(D�(ÏÐÑÏ¦7Ð c cˆ¢cµ
 `£cÏË `àB¤GS
ÑöÌ˜“(˜
�à7æ7$”(±š(ü‹)zªŸ” Ÿ ûÈ�)‹É“)¡Ùà7¡¤¼)¢µßà7¢ÛùÑLû)¦7£·ß£acfhÀ)Ú)üŒ*"�*ÒÓÒ¦7Ó¦7ž’*ž
£à7æ7$“*¹
,™*üÜ*lª¥”¦¦¥ûÈá*‹Éä*§Ùà7§¤†+¨™à7¨ÛÅ+¦7PRUWŠ+¤+üÎ+|ªª”««ªûÈÓ+‹ÉÖ+¬Ùà7¬¤€,íßà7ÛËÕT¿,¦7®ïß®acfh„,ž,üÑ,B\Ô,ÔÕÔ¦7Õ¦7Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙ¿ßÀßÁßLessÁÂßÃßÄß~ÅßÆßÇßGreaterÁÈßåºÝÈnûê7©à,©
®à7æ7$á,¹
,ç,üË-nª°”±±°ûÈÐ-‹ÉÓ-²Ùà7²¤ö-³ºà7³Ûµ.¦7´»´[]`bú-”.üÀ.2Ã.Ö×Ö¦7×¦7£×¯Ç.¯
´à7æ7$È.¹
,Î.üŸ<aª¶”¸¶¸ûÈ¤<‹É½<·Ùà7·¤§<æ7\À<æ7ê!<ø<¦7¹¼ÀÂWY«<bdü¡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Üª…$ºR±ÃR|~Ö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—Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¦7–µ–½—¾¾½µÍì±ñþ\ÍìÛð�]¿–"Ûð¿ÆÛü»]U¿Ûð˜ò˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
à7¿Û±ñüé]'ÄÛ<°^
¼à7æ7±ñÛð…$„]±�]äæàâ¿]üÍ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…$òc±ƒdŠdü¾f«ü�e'$ Use [`Yoke::try_attach_to_cart()`].Á»eúüÃedÀól¬fÄÅfæ7ÄÄÆÛÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
à7ÄÛ±ñàðµ–ÃÃµæñÞf
Âà7æ7±ñ…$êf±ûf#%‚güŸh+ªÆ”ÈÆÈûÈ¤h‹É½hÇÙà7Ç¤§h¦7ÉËÌÍÐÔÙAC«hLNü×q;üÑh1. Obtain a valid reference to the yokeable dataÁ
 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Å
Éà7æ7$ê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Å
Ëà7æ7$Ê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$»�ü��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 
à7ÔÅÔÎÞÏÎÏÅÍì² ¸�ÍìðŸ¤Å�–"ðŸæ7|Ê�ðŸ–¡˜"² ×�
Íà7æ7² ðŸ$¼�±Â�ikdfü‰§~üê’(% Mutate the stored [`Yokeable`] data.Á—“úüŸ“YV If the callback needs to return `'static` data, then [`Yoke::with_mut_return`] can beÁüý“VS used until the next breaking release of `yoke`, at which time the callback to thisÁüØ”74 function will be able to return any `'static` data.Á”•úüœ•EB See [`Yokeable::transform_mut()`] for why this operation is safe.Áæ•úlî•¢¿€–úüˆ–B? This can be used to partially mutate the stored data, providedÁüÏ–)& no _new_ borrowed data is introduced.Áý–ú\…—«Àü•—! # use yoke::{Yoke, Yokeable};Á´»—ÝÀÜÖ—üÀœö— # use std::mem;ÁüŽ˜7¡ÁüÊ˜!âÁüð˜K�Â<À™áÂ,Ì™æüüÖ™FC # fn load_object(filename: &str) -> Yoke<Bar<'static>, Rc<[u8]>> {Áü¡š7ÊýüÝšLI #     Yoke::<Bar<'static>, Rc<[u8]>>::attach_to_cart(rc, |data: &[u8]| {Áü®›RO #         // A real implementation would properly deserialize `Bar` as a wholeÁœ…œ #         Bar {Áü�œNK #             numbers: Cow::Borrowed(bincode::deserialize(data).unwrap()),ÁüðœMJ #             string: Cow::Borrowed(bincode::deserialize(data).unwrap()),ÁüÂ�$! #             owned: Vec::new(),Á|ë� #         }Ádÿ�¯ÿ<�žáÂœžú¼¤ž #[derive(Yokeable)]Á¤Àž struct Bar<'a> {ÁüÙž     numbers: Cow<'a, [u8]>,Áìýž     string: Cow<'a, str>,Á¼ŸŸ     owned: Vec<u8>,Á,»Ÿ‚ÆÅŸúüÍŸ96 // `load_object()` deserializes an object from a fileÁü‹ @= let mut bar: Yoke<Bar, _> = load_object("filename.bincode");ÁüÐ *' assert_eq!(bar.get().string, "hello");Áüÿ :7 assert!(matches!(bar.get().string, Cow::Borrowed(_)));Áü¾¡EB assert_eq!(&*bar.get().numbers, &[0x68, 0x65, 0x6c, 0x6c, 0x6f]);Áüˆ¢;8 assert!(matches!(bar.get().numbers, Cow::Borrowed(_)));ÁüÈ¢'$ assert_eq!(&*bar.get().owned, &[]);Áô¢úÄü¢ bar.with_mut(|bar| {Áü™£/,     bar.string.to_mut().push_str(" world");ÁüÍ£63     bar.owned.extend_from_slice(&[1, 4, 1, 5, 9]);Á<ˆ¤´�”¤úüœ¤0- assert_eq!(bar.get().string, "hello world");ÁüÑ¤74 assert!(matches!(bar.get().string, Cow::Owned(_)));Áü�¥41 assert_eq!(&*bar.get().owned, &[1, 4, 1, 5, 9]);ÁüÆ¥(% // Unchanged and still Cow::BorrowedÁüó¥EÆ¯ü½¦;–°<ý¦ÅÇD�§Ô¦7Ûð³4ÅÔÑ—ÒÑÒÅ÷ñ�§Ûð<É§Ó–"ÛðÓà7ÔÛüÓ§3ÓÛðâ¶˜"³4üÛ§+
Ðà7æ7ÔÛð$¨§±®§™§Ž�×§ü†¬¦üÁ¨XU Mutate the stored [`Yokeable`] data, and return `'static` data (possibly just `()`).Áž©úü¦©TQ See [`Yokeable::transform_mut()`] for why this operation is safe, noting that noÁtÿ© `'static`.Á’ªú¼šª ### Will be removedÁü¶ª\Y This method will be removed on the next breaking release of `yoke`, when the callback ofÁü—«ZW [`Yoke::with_mut`] will gain the ability to return any `R: 'static` and supersede thisÁ\ö« method.Á|�¬�¶Ûð£ÅÔÕ—Ö£×Ö×ÕÅ÷ñ¡¬Íì…¼¤¬Æ¶<Õ¬Ø–"ÛðØí¶üß¬8ØÛðû¼˜"…¼–…¼<¤
Ôà7æ7ÔÛð…¼$¯¬±µ¬�¬¡£œžã¬üÜ®6üüMJ Helper function allowing one to wrap the cart type `C` in an `Option<T>`.Áœã®¦7™AÅÅ
Ùà7æ7$÷®üÁ°)ªÛÛûÈÆ°ÜÙà7Ü¤É°ŒŒÑ�õ€‘…€ †|À§M
à7³4ÝÞikÍ°ü¢·,üñ°?< Construct a new [`Yoke`] from static data. There will be noÁüµ±@= references to `cart` here since [`Yokeable`]s are `'static`,Áüú±2/ this is good for e.g. constructing fully ownedÁü±²)& [`Yoke`]s with no internal borrowing.Áß²úüç²IF This is similar to [`Yoke::new_owned()`] but it does not allow you toÁüµ³A> mix the [`Yoke`] with borrowed data. This is primarily usefulÁüû³,) for using [`Yoke`] in generic scenarios.Á¬´úl´´¢¿Æ´ú\Î´«À¬Þ´¿ÀÜø´üÀ˜µúü µ41 let owned: Cow<str> = "hello".to_owned().into();ÁüÙµA> // this yoke can be intermingled with actually-borrowed YokesÁüŸ¶A> let yoke: Yoke<Cow<str>, ()> = Yoke::new_always_owned(owned);Áå¶úüí¶$¹€<–·ÅÇ„©·à7õ¿ÚÚ
Ýà7õDº·ü»»üï¹.+ Obtain the yokeable out of a `Yoke<Y, ()>`Á¢ºúüªº74 For most `Yoke` types this would be unsafe but it'sÁüæº=: fine for `Yoke<Y, ()>` since there are no actual internalÁt¨» referencesÁlÂ»õ¿à7ÚÚ
Þà7$Ð»ü“¾3ªà”ââàûÈ˜¾‹É±¾áÙà7á¤›¾™Aãä57Ÿ¾@BüåÅ+üÍ¾?á¿ü‘¿@«ÀüÖ¿2öÀü�À)³Á»ÀúüÃÀIF This can be paired with [`Yoke:: wrap_cart_in_option()`] to mix ownedÁ´‘Á and borrowed data.Á¬Áúü´ÁXU If you do not wish to pair this with borrowed data, [`Yoke::new_always_owned()`] canÁü‘Â74 be used to get a [`Yoke`] API on always-owned data.ÁÍÂúlÕÂ¢¿çÂú\ïÂ«À¬ÿÂ¿ÀÜ™ÃüÀ´¹ÃÝÀÔÃúüÜÃ4ªÄü•ÄAéÄüÛÄHE let yoke: Yoke<Cow<str>, Option<Rc<[u8]>>> = Yoke::new_owned(owned);Á¨Åúü°Å$¹€<ÙÅÅÇLòÅà7™Aßß
ãà7æ7õc üŸÉ1üÚÇB? Obtain the yokeable out of a `Yoke<Y, Option<C>>` if possible.Á¡Èúü©ÈHE If the cart is `None`, this returns `Ok`, but if the cart is `Some`,ÁüöÈ$! this returns `self` as an error.ÁŒ¦É™AÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
à7™Aßß
äà7æ7$¸ÉüãËHªæ”èèæûÈèË‹É�ÌçÙà7ç¤ëËæ7œ„Ì™AéACïËLNü³ÙRü²ÌJG Converts a `Yoke<Y, Option<C>>` to `Yoke<Y, CartableOptionPointer<C>>`Áü�Í96 for better niche optimization when stored as a field.Á¿ÍútÇÍ¬ßÚÍú<âÍÅÇÌîÍÉŒœŒÎ¸ˆ¤Îúü¬Î-* let yoke: Yoke<Cow<[u8]>, Box<Vec<u8>>> =ÁüÞÎDA     Yoke::attach_to_cart(vec![10, 20, 30].into(), |c| c.into());Á§Ïúü¯Ï1. let yoke_option = yoke.wrap_cart_in_option();ÁüåÏMJ let yoke_option_pointer = yoke_option.convert_cart_into_option_pointer();Á<·ÐÅÇÃÐúüËÐ#  The niche improves stack sizes:ÁóÐú<ûÐÅÇœ‡Ñ¸ˆüŸÑ2/ use yoke::cartable_ptr::CartableOptionPointer;Á¤ÖÑ use std::rc::Rc;ÁïÑúü÷Ñ" // The data struct is 6 words:ÁüžÒ # #[derive(yoke::Yokeable)]ÁüÂÒ # struct MyDataStruct<'a> {ÁüæÒ+( #     _s: (usize, usize, usize, usize),Á´–Ó #     _p: &'a str,Á<±ÓáÂü½Ó(% const W: usize = size_of::<usize>();ÁüêÓ1. assert_eq!(W * 6, size_of::<MyDataStruct>());Á Ôúü¨ÔOL // An enum containing the data struct with an `Option<Rc>` cart is 8 words:ÁÄüÔ enum StaticOrYoke1 {Áü™Õ/,     Static(&'static MyDataStruct<'static>),ÁüÍÕ>;     Yoke(Yoke<MyDataStruct<'static>, Option<Rc<String>>>),Á,�Ö‚ÆüšÖ2/ assert_eq!(W * 8, size_of::<StaticOrYoke1>());ÁÑÖúüÙÖW
à7‰‰š#‹¿#ŒÌ#H_}öáf@æ7åå
éà7æ7$ÛÙüÝÞWªë”ííëûÈâÞ‹ÉûÞìÙà7ì¤åÞ´ÔœþÞ…ãî<>éÞGIü�á1ü»ßQN Obtain the yokeable out of a `Yoke<Y, CartableOptionPointer<C>>` if possible.Á‘àúü™àHÉÐüæà$œÑŒ¤á…ãÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
à7…ãêê
îà7æ7$¶áüúé%ü×âDA This trait marks cart types that do not change source on cloningÁœãúü ãMJ This is conceptually similar to [`stable_deref_trait::CloneStableDeref`],ÁüîãOL however [`stable_deref_trait::CloneStableDeref`] is not (and should not) beÁü¾äZW implemented on [`Option`] (since it's not [`Deref`]). [`CloneableCart`] essentially isÁü™åUR "if there _is_ data to borrow from here, cloning the cart gives you an additionalÁìïå handle to the same data".Á�æúd‘æò^üžæˆ… This trait is safe to implement on `StableDeref` types which, once `Clone`d, point to the same underlying data and retain ownership.Á§çúü«çŽ‹ This trait can also be implemented on aggregates of such types like `Option<T: CloneableCart>` and `(T: CloneableCart, U: CloneableCart)`.Áºèúü¾èŠ‡ Essentially, all data that could be referenced by a Yokeable (i.e. data that is referenced via a [`StableDeref`]) must retain the sameÁüÉé0- pointer and ownership semantics once cloned.Ál‹êïïã^üúé(Øë^,šêïã^)²ðã^4²ð)üéì9¥ññß]õìï’4løì8ü»î2Ôó¥ôôóÎì«1Ëî¥1Çîü™ï ³4üâózü¾ïgd Clone requires that the cart type `C` derefs to the same address after it is cloned. This works forÁ¼¦ð Rc, Arc, and &'a T.Á¾ðúüÂð`] For other cart types, clone `.backing_cart()` and re-use `.attach_to_cart()`; however, doingÁü£ñ63 so may lose mutations performed via `.with_mut()`.ÁÚñúüÞñ_\ Cloning a `Yoke` is often a cheap operation requiring no heap allocations, in much the sameÁü¾òa^ way that cloning an `Rc` is a cheap operation. However, if the `yokeable` contains owned dataÁü óA> (e.g., from `.with_mut()`), that data will need to be cloned.Áª÷”ùù÷ûÈçó‹É€ôøÙà7ø¤êóïæ7lƒôúØà7úÛ,Öô¦7ûÙûoqîóz|µô¼ãô,æôÙÙ¦7¦7öìôö
ûà7æ7$íôüøþ+ªý”ÿýÿûÈýþ‹É–ÿþÙà7þ¤€ÿ¦7€…‹‘˜�£©GI„ÿRTüƒ’ìüªÿWT Allows one to "project" a yoke to perform a transformation on the data, potentiallyÁü†€ZW looking at a subfield, and producing a new yoke. This will move cart, and the providedÁüå€RO transformation is only allowed to use data known to be borrowed from the cart.Á¼�úüÄ�\Y If producing the new [`Yokeable`] `P` requires access to the cart in addition to the oldÁü¥‚_\ `Y`, then [`Yoke::map_with_cart`] can be used if the cart satisfies additional constraints.Á‰ƒúü‘ƒUR The callback takes an additional `PhantomData<&()>` parameter to anchor lifetimesÁüëƒQN (see [#86702](https://github.com/rust-lang/rust/issues/86702)) This parameterÁüÁ„+( should just be ignored in the callback.Áñ„úüù„PM This can be used, for example, to transform data from one format to another:ÁÎ…ú<Ö…ÅÇ´â…ÝÀ¬ý…¿À,—†æüü¡†PM fn slice(y: Yoke<&'static str, Rc<[u8]>>) -> Yoke<&'static [u8], Rc<[u8]>> {Áüö†1.     y.map_project(move |yk, _| yk.as_bytes())Á,¬‡‚Æ<¶‡ÅÇ
¡æ7ü¡�—‚�‚üÍì…�–’÷ñ™’ƒÙ…�ƒ¤Ë’„–"Ûðà7„Û• • – »8Fu\»Ÿ„³4üì’‚„Ûð‡�˜"…�„ÛÜÓ“
€à7æ7…�Ûð$œ’±¢’ÝßáãÏ’ð’ü¿š¢üá—FC This is similar to [`Yoke::map_project`], however it does not moveÁü¬˜RO [`Self`] and instead clones the cart (only if the cart is a [`CloneableCart`])Áƒ™úü‹™a^ This is a bit more efficient than cloning the [`Yoke`] and then calling [`Yoke::map_project`]Áüñ™IF because then it will not clone fields that are going to be discarded.Á”Æšº¦7—ŒŒÑ�õ€‘…€ †|À§M
¡æ7üº†¡‡—ˆˆ†‡üÍì¸•àšÍìù”ãš‰Ù¸•‰¤œ›ð÷l½›Š–"ù”ºà7ŠÛ• • – »8Fu\»ŸŠ³4ü×›‰Šù”Ù–˜"¸•ŠÛÜÅœ
…à7æ7º¸•ù”$íš±óš,Ùš ›Û›üØ®‰ü¹ TQ This is similar to [`Yoke::map_project`], however it can also bubble up an errorÁ´’¡ from the callback.Á¡ú<µ¡ÅÇ´Á¡ÝÀ¬Ü¡¿Àüö¡&# # use std::str::{self, Utf8Error};Á,¡¢æül«¢
 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ÛðÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ËŽ–ü¡Œ—�–ŽŒ�Žü½�ï®÷ñò®Íìø¢õ®�Ù…��¤²¯�–"Ûðà7�Û• • – »8Fu\»Ÿ�³4üÓ¯��Ûð�¤˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
…��Ûø¢üº°&
‹à7æ7…�Ûðø¢$ø®±þ®FILOIL¶¯×¯üº·¿üØ´JG This is similar to [`Yoke::try_map_project`], however it does not moveÁü§µR²‘þµúü†¶aœ’üì¶Iˆ“´Á·ð”ù”Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
þ”–üº’¡“—”–•”’•“üý•ß·�–â·ÍìÏ¨å·–Ù¸•–¤©¸ð÷lÊ¸—–"ù”ºà7—Û• • – »8Fu\»Ÿ—³4üä¸”—ù”ü©˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¸•—ÛÏ¨üÒ¹&
‘à7æ7º¸•ù”Ï¨$ï·±õ·,Ø·cfilfi¸è¸üŽÀ³üÕ½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…�À¯$ÆÀcaptureÁ<ÔÀ±èÀjleg°ÂïÀü²ÉéüëÆ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…�À¯$ÿÉ³°<�Ê±¡ÊrthjlnðË¨ÊüäÒÐüüÏ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|Â
…�¨Ûø¢¦¢ü¡¤¥¥–¦¤¥¦ü
 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º¸•ù”$Úˆ±àˆ,ÆˆÞàâä�‰®‰ü£•·üØŽ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ÄÛÄÆÛü –’ÄÛð�è˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
…�ÄÛø¢üŒ—&ÄÛ<Ò—
¿à7æ7…�Ûðø¢$Å•±Ë•!$'*-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
à7�“”’•ˆ–—“˜ˆö\ŸÑ€ƒ4Ôæ7“Ì“ÑÑÌÍì ÷‡à
Ðà7æ7 ÷$ŠàüåãBü»áPÆò�âúü˜âJG This function wraps the cart into the `B` variant. To wrap it into theÁüçâ74 `A` variant, use [`Self::wrap_cart_in_either_a()`].Á£ãúü«ã'Òô¬ìã¦7ŒŒÑ�õ€‘…€ †|À§M
à7�“”’•ˆ–—“˜ˆö\ŸÑ€ƒ4Ô’æ7Ì’ÓÓÌÍìõú‚ä
Òà7æ7õú$…ä\È†Î†€³4\Ù»ß»€³4\Ï‰Õ‰€³4däDèÙ»8\¼• ×Ø»8– ×ØÌ®+ü¬&üÊ_\ The `Yokeable<'a>` trait is implemented on the `'static` version of any zero-copy type; forÁüªHE example, `Cow<'static, T>` implements `Yokeable<'a>` (for all `'a`).Áóú|÷ One can useÁü‡_\ `Yokeable::Output` on this trait to obtain the "lifetime'd" value of the `Cow<'static, T>`,ÁüçFC e.g. `<Cow<'static, T> as Yokeable<'a>'>::Output` is `Cow<'a, T>`.Á®úü²OL A [`Yokeable`] type is essentially one with a covariant lifetime parameter,Áü‚RO matched to the parameter in the trait definition. The trait allows one to castÁüÕ1. the covariant lifetime to and from `'static`.Á‡úü‹a^ **Most of the time, if you need to implement [`Yokeable`], you should be able to use the safeÁüíC@ [`#[derive(Yokeable)]`](yoke_derive::Yokeable) custom derive.**Á±úüµRO While Rust does not yet have GAT syntax, for the purpose of this documentationÁüˆ	OL we shall refer to "`Self` with a lifetime `'a`" with the syntax `Self<'a>`.ÁüØ	GD Self<'static> is a stand-in for the HKT Self<'_>: lifetime -> type.Á 
úü¤
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ë^<ËÙã^#¢™ã^.¢™(ÛÜÝÞßÛÜÝÞßÍìë^ÔÛ„±ï™Ô¾ç™„šÞÜßÝÆ|±üÙ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_mut(move |bar
öûˆ«E4öûˆ\Ï¡|àŽ„öeüŒW|²IüÄÄªý”þþýûÈÉ‹ÉÌÿÙà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>Á‚‚�‚à7æ7Ã5ÆÛà7Û³4¬Âg"\â‰"‰"›"›"ÌŽDŸ”Ëµ"üå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”ŠŠˆv†J˜vœ–JË1H_}öáf@‹Œ((*´’L,’L‰‰‰‰§‹‰ïíe¼îËè¿*ƒ2Ì®LL®L‰‰• • – »8Fu\»Ÿƒ2(ÝI”ŽŽˆvè¿cƒ2†J˜vö¿c¸âHË1�Àc�giÚÛÜÚË1Û c cˆ¢cµ
 `£cÏË `àB¤GS
ÜöÌ�ÝI�
�ƒ2±ÜœüÊ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ö\ŸÑ€ƒ4Ô“”–—”•‹3Ã2—˜‘3Ã2LNQS§!§!��
”‹3‘3§!§!‹3Ã2��ÍóÀ��‹3ù!ù!��
—‹3‘3ù!ù!‘3Ã2��¾ôË��‘3(
Ñ
 º	šÃ	›š›ï|Ž€{Ø‹3
°Ø‘3
´Ã2œÙœ´·»¾ŠŒÝÝÃ2Ã2™
Ñ
™
œ‹3‘3ÝHØ
!º	žÃ	ŸžŸï[Ž€ZÃ2hkor_c!º	¡Ã	¢¡¢ï·Ž€¶µß‹3‹3°µß‘3‘3´Ã2£·ß£øûÿïñÞßÞÃ2ßÃ2 Ø
 
£‹3‘3R¹
Yã
"º	¥Ã	¦¥¦ï·Ž€¶™‹3°™‘3´Ã2§›§ïòöùŠ�¥ààÃ2³4¤ã
¤
§‹3‘3ö(
ç
#º	©Ã	ªª©ï¯Ž€®¿c‹3
°¿c‘3
´Ã2«Àc«çêîñŠŒáâãáÃ2â c cˆ¢cµ
 `£cÏË `àB¤GS
ãöÌ¨
ç
¨
«‹3‘35±<øÆ$Ô³4®¯°±²ÛÜÝÞß±¯°²ÒXù0þ¬¬³4øÊ$HÍää³4ä³4ÔÛ¬×¬
¯Ô Øø¦(x©³4»ÿ¬¬
°Ô ¹ø†* �»ÿ³4¬¬
±Ô¼Ž •øèthëÔ³4—³4¬—³³¬Íì¸�ù¸�8´–"¸�´»ÿø·$´¸�Ž‚˜"³4à¿
²Ô¸� „±Štv»øÆ$Ô¶¶Ã4·¸¹º»ÛÜÝÞß¸º»¹ÒXù0þµµÃ4øÊ$HÍååÃ4åÃ4ÔÛµ×µ
¸Ô Øø¦(x©Ã4¥„µµ
¹Ô ¹ø†* �¥„Ã4µµ
ºÔ¼Ž •øèthëÔÃ4¸�³4µ—¼¼µà�ùò�8½–"¸�½¥„ø·$½¸�ê†˜"³4à¿
»Ô¸� „±Šqs»øÆ$Ô¿¿Ó4ÀÁÂÃÄÛÜÝÞßÃÁÄÂÒXù0þ¾¾Ó4øÊ$HÍææÓ4æÓ4ÔÛ¾×¾
ÁÔ Øø¦(x©Ó4�‰¾¾
ÂÔ ¹ø†* ��‰Ó4¾¾
ÃÔ¼Ž •øèthëÔÓ4¸�³4¾—ÅÅ¾à�ùò�8Æ–"¸�Æ�‰ø·$Æ¸�Æ‹˜"³4à¿
ÄÔ¸� „±Šqs»øÆ$ÔÈÈã4ÉÊËÌÍÛÜÝÞßÌÊÍËÒXù0þÇÇã4øÊ$HÍççã4çã4ÔÛÇ×Ç
ÊÔ Øø¦(x©ã4Ý�ÇÇ
ËÔ ¹ø†* �Ý�ã4ÇÇ
ÌÔ¼Ž •øèthëÔã4¸�³4Ç—ÎÎÇà�ùò�8Ï–"¸�ÏÝ�ø·$Ï¸�¢�˜"³4à¿
ÍÔ¸� „±Šqs»øÆ$	ÔÑÑó4ÒÓÔÕÖÛÜÝÞßÔÓÕÖÒXù0þÐÐó4øÊ$HÍèèó4èó4ÔÛÐ×Ð
ÓÔ Øø¦(x©ó4¹’ÐÐ
ÔÔ ¹ø†* �¹’ó4ÐÐ
ÕÔ¼Ž •øèthëÔó4¸�³4Ð—××Ðà�ùò�8Ø–"¸�Ø¹’ø·$Ø¸�þ”˜"³4à¿
ÖÔ¸� „±Šqs»øÆ$
ÔÚÚƒ5ÛÜÝÞßÛÜÝÞßßÝÜÞÒXù0þÙÙƒ5øÊ$HÍééƒ5éƒ5ÔÛÙ×Ù
ÜÔ Øø¦(x©ƒ5•—ÙÙ
ÝÔ ¹ø†* �•—ƒ5ÙÙ
ÞÔ¼Ž •øèthëÔƒ5¸�³4Ù—ààÙà�ùò�8á–"¸�á•—ø·$á¸�Ú™˜"³4à¿
ßÔ¸� „±Šqs»øÆ$Ôãã“5äåæçèÛÜÝÞßèæçåÒXù0þââ“5øÊ$HÍêê“5ê“5ÔÛâ×â
åÔ Øø¦(x©“5ñ›ââ
æÔ ¹ø†* �ñ›“5ââ
çÔ¼Ž •øèthëÔ“5¸�³4â—ééâà�ùò�8ê–"¸�êñ›ø·$ê¸�¶ž˜"³4à¿
èÔ¸� „±Šqs»øÆ$Ôìì£5íîïðñÛÜÝÞßñïðîÒXù0þëë£5øÊ$HÍëë£5ë£5ÔÛë×ë
îÔ Øø¦(x©£5Í ëë
ïÔ ¹ø†* �Í £5ëë
ðÔ¼Ž •øèthëÔ£5¸�³4ë—òòëà�ùò�8ó–"¸�óÍ ø·$ó¸�’£˜"³4à¿
ñÔ¸� „±Šqs»øÆ$
Ôõõ³5ö÷øùúÛÜÝÞß÷úøùÒXù0þôô³5øÊ$HÍìì³5ì³5ÔÛô×ô
÷Ô Øø¦(x©³5©¥ôô
øÔ ¹ø†* �©¥³5ôô
ùÔ¼Ž •øèthëÔ³5¸�³4ô—ûûôà�ùò�8ü–"¸�ü©¥ø·$ü¸�î§˜"³4à¿
úÔ¸� „±Šqs»ø Æ$ÔþþÃ5ÿ€�‚ƒÛÜÝÞß‚€ƒ� ÒX ù0 þýýÃ5ø!Ê$H!ÍííÃ5íÃ5ÔÛý!×ý
€Ô !Øø!¦(x!©Ã5…ªýý
�Ô !¹ø!†* !�…ªÃ5ýý
‚Ô¼Ž !•ø!èth!ëÔÃ5¸�³4ý—„„ýà�!ùò�8!…–"¸�……ªø!·$…¸�Ê¬˜"³4à!¿
ƒÔ¸� !„±!Šqs!»ø"Æ$Ô‡‡Ó5ˆ‰Š‹ŒÛÜÝÞß‹‰ŒŠ"ÒX"ù0"þ††Ó5ø#Ê$H#ÍîîÓ5îÓ5ÔÛ†#×†
‰Ô #Øø#¦(x#©Ó5á®††
ŠÔ #¹ø#†* #�á®Ó5††
‹Ô¼Ž #•ø#èth#ëÔÓ5¸�³4†—��†à�#ùò�8#Ž–"¸�Žá®ø#·$Ž¸�¦±˜"³4à#¿
ŒÔ¸� #„±#Šqs#»ø$Æ$Ô��ã5‘’“”•ÛÜÝÞß”’“•$ÒX$ù0$þ��ã5ø%Ê$H%Íïïã5ïã5ÔÛ�%×�
’Ô %Øø%¦(x%©ã5½³��
“Ô %¹ø%†* %�½³ã5��
”Ô¼Ž %•ø%èth%ëÔã5¸�³4�—––�à�%ùò�
â9ç!NµÅÚßåêü°ÌüKBox<T>Áalloc::boxed::BoxÁalloc::boxedÁ¬Û¼Àalloc::borrow::CowÁ
alloc::borrowÁRc<[u8]>Áo	std::syncÁ	Option<T>ÁYoke::get()Áhttps://docs.rs/zerovecÁ¸ÑÃÑCow<'a, str>ÁúÑ‘ÒoÀstd::sync::ArcÁ´ÒÂÒZeroVecÁàÒ¸Ñ.get()Á
Yoke<Y, C>ÁˆÓúÑArc<T>Á®Ó´Ò	alloc::rcÁÍÓàÒÑ	Yoke::getÁåÓðÓˆÓRc<T>Á‹Ô®Ó
alloc::rc::RcÁ¢ÔÑ¤ÍÓÁÔåÓðÓÙÑáÔ‹Ô¬£Ò÷Ô¢ÔÑŒ¤ÐÒÁÔÃÑÙÑáÔ¬À‘Ò£Ò÷ÔoÂÒ¤ÐÒ-ÑSelf::into_rawÁSelf::drop_rawÁš#‰&Yoke::convert_cart_into_option_pointerÁœ®[-crate::Yoke::convert_cart_into_option_pointerÁcrate::YokeÁÀstd::ptr::read_unalignedÁÚÑstd::ptrÁ¾ÖÑÖš#®[œîÖÀ§×Ù×ŒÚÑö×�Ø¾Ö®[š#ÑÖœîÖ§×Ù×Àö×�ØÚYoke::erase_box_cart()Ácrate::Yoke::erase_box_cartÁÑÙ××ÙòÙÑÙ××ÙòÙÙ×ŒÑ“Yoke::map_projectÁYoke::map_project()ÁÐÒSelf::wrap_cart_in_either_bÁSelf::wrap_cart_in_either_a()ÁYoke::try_attach_to_cart()Á¬Û¼Yoke::with_mut_returnÁYokeable::transform_mut()ÁýÙYoke::new_always_ownedÁYoke::attach_to_cartÁÐÒ.map_project()ÁâÚSelf::wrap_cart_in_either_b()Á–ÛYoke::into_backing_cartÁ‚ÜœÜYoke::new_always_owned()ÁÄÜßÜþÜYoke::try_map_with_cartÁ—Ý¿Ý‚ÜçÝYoke::attach_to_cart()ÁßÜYoke::try_map_project_clonedÁ–Þð#r—ÝYoke::try_attach_to_cart_badlyÁ¿ÝYoke:: wrap_cart_in_optionÁçÝÊÞYoke::map_project_clonedÁëÞ–Þð#r¡ßÊß0https://github.com/unicode-org/icu4x/issues/1061ÁÊÞõßëÞð#�ré! Yoke::try_attach_to_cart_badly()Á¡ßYoke:: wrap_cart_in_option()ÁÊß#1061Á³àõßYoke::attach_to_cart_badlyÁ�áYoke::new_ownedÁ¸á®[Yoke::try_map_projectÁßá³àõá�ášâ¸á_®[.https://github.com/rust-lang/rust/issues/86702Á¹âßáYoke::attach_to_cart_badly()ÁõáYoke::new_owned()Ášâ_#86702Á®[åÓ€ã¹âSelf::wrap_cart_in_either_aÁYoke::try_attach_to_cartÁ¿ãYoke::with_mutÁ†æãÑ_Yoke::map_with_cartÁÁÔåÓ†ä€ã¬äÌä¿ãYokeable::transform_mutÁïä†æãÑ$stable_deref_trait::CloneStableDerefÁçšåÁÔåÓøÚ†ä¶Û¬äØÛÌä¬àåßïäýP†–"ÑŒ’æÐÒçÁÔâÚøÚšå–Û¶ÛØÛ¬œÜàåýçïÄÜ’æþÜ#[derive(Yokeable)]Áyoke_derive::YokeableÁÃSelf::transform()ÁàåßýSelf::transformÁ¤èœÜ¼èPßèýÙÃàå‰é¤è¼èœÜÃýßè‰éàåœÜÑŒ«EÑ«E
«E4ÑÙï
ÃLðìŠ � Ø™ºãàéæ³Œ"�"“"–"Û Þ ã ŒMÃMÐLÇLùMÌìÍì“íµßíßïÃLðìŠ � Ø™ºãàéæ³Œ"�"“"–"Û Þ ã ŒMÃMÐLÇLùMÌìÍì“íµßíßïé!ÃLðìŠ � Ø™ºãàéæ³Œ"�"“"–"Û Þ ã ŒMÃMÐLÇLùMÌìÍì“íµßíßÙé!ïÃLðìŠ � Ø™ºãàéæ³Œ"�"“"–"Û Þ ã ŒMÃMÐLÇLùMÌìÍì“íµßíßÙÃLðìŠ � Ø™ºãàéæ³Œ"�"“"–"Û Þ ã ŒMÃMÐLÇLùMÌìÍì“íµßíßÃîVbªàXrÑhc(B}wÀ�Œ¦«ÆÍë¨Kv$øePIKÅj–þ¢˜ÀÃJÓ˜ÍoìQZßP!=TÞ8å!ûñöˆb
y 1'Bz“™h?7dîw·²†ø"ßt.�z´u;–Ê†Tä»ŠõŠ)”›©J�r{cÏêOý¾	}Ô;‚0fz[ŸŒ”DÖëP¥DMÑük¸_“
Åë@1ã¨‘‹¥ç½„"ÚjC.N„)]PÊ1×¦OœQmª¶Fú-y, Žš£q:‰Ý—%‚Ý«›˜°¬O\s=ñô¡¨<q¨þÑ|òFe¬;bnY®¬†ÉÍü�ˆ‡~‚‡N4@Ä%v¡È·|†(øu’4H@7ú¸Y½yk¾¸rióÈK»7‰$×î§.*?eÏ~c }
{(À¼‡kÌtW—/Œ±Ø�kÑÎüÛ-f2:IÐPl@�Næ_’õWÛ_~b8ëÖmV+xKQ•êµNNÎÒÇØÁêŒ“r“ZQdp‰9ãek�,©ÓR›×ÈŽ¯³»¤
UH×SƒT2;®ˆ ×ìRöÃÆ~´¶Œ<‡¯npþ�Ä—pÅ;Ë©ÒØ¶„ùÆo4[ùp½¥ü¢Bƒ=~�h
˜“ŠøÛjaÉ4~{Æóv›Ç°ï;‹²ª?Ññe\4Šš%œ
‹�\ŠÆµ*�y÷ˆT4G˜«Àhª×BãÒÛûpÜQ¶çí�P‡æv¤Y'Õûí¾›·yjß™±U_¤4?%º¾ÞÌÉ”êe·§ ! ‰_S5UëyXzh¥Êúù@Qz¯îÁåF#>…¸dó¿,YWNÈýŠáLCd|lÝjf¾L³¦bwtá=_©2—Ü�†–'�ð«ç¢(é5S{ž�Õ˜ù!OŽ´¤8ro¦|K¬[Z` ˆEº\QêóèþÃy®�‚ò%H¹¤…3õ�-q&]·Ý;[3—7NËõŸ“>ÓË| ÍÌÏ" |ñ—Ý®ó{t—àà¥WªºÓ–+ƒT#ëHÔº†•Îz„ÿP>yŸ¸öRÞÉŸHŠlÚ)ºE,Dåj/é×±-—K��×ûö}×|·tbéWË&«ñ S^p~bü2$2é¦u…¨l¿|Œ¿£B`Ï¤‚¼“K�±îLmð4�Ç–ÀšLGbŒ[jj~mMã§(üO& ˜SKËpS+µÃ¦™ù×Üâ?–É×È²¬‡Êæö‚ŠÙ\–GÇæ0ÑUj4ÜÔ&æ°wåÛ/B+ºm`Šª•®ÒíÖ³v]�éówBfšC3ÿÔÂk00îºMGKÌ$‚ÜÁxèÅ×#èöFèF&˜4ØÙ§´…uñ-à�ã0G°æÚï½ôci?«Ýì/á5¸·}Ïÿ!h&éé
Bî�¢[Šù4m.§²zÖ¼TdåÿÅzª)=åF´G–~žä†ÚµPÙÏ3€¯åhíH-�m4«Z‘}`)5¶‚8hw.»†r&¢¢ªn`
C%qèÒdÃÂ}ãXÌÞ!Ú™	×r„©šeÑíµKò,”=
éìT¾«0T12î¬n. i"gšY€PÆ)v¥1šIC·ÇV^·{™òê³h@·¿×:¸›�â×�¨Ú%J¶)è§îÑ`ÙÉóîO=œáÕ0Äµf%¢9‡‚úÀ @ÊËˆâÝ¯à>ÎZuv÷·Âƒ N›`]lÑÆŽ¬Ž�Ÿ‘J*S¼Þ¹é®ÿ0Ï,<:pLÔâ�“%íÕ„Œc‘ :a>„ÄÏ€q*
OŸ«9H“Ci	#O
ÃH‚ÈŒO‰I¦ƒ‡�½Èg%ž¾�úLñ¾
[L±¡÷)è’éA—8"b³³¯™Ñn?#¨,‰ê^�àš4@Ó—Å/áU.˜sJ›oüœ'‰6E�0Ê°NýPK/B`mÙ=ý.Ëj�*D
±õÅ:aEu×8g0q…'œPðtD¹sÚ3
Òñ©¸ÿB‚²-m™‚I“!”¼/é†J¥ÛÜ+%Þ—ÁÓ©(³V3áÀr]¤L €�3GÐ–MGçÈtIFÚPoï¸�ø‰ã7¡±©3«µììÑxHs¤òõzØIÙ÷°º"/fÞ²>sK6ÝÎÔÕrö'#…–„¦wÚAZokW›h¯ýæÃ£h}ƒqÓ(Í/'&oX’Àeg1È×¬²$@N
XÿÀo•a±8Ð¬÷34€oË)¡ˆü'S³(Ý…æÌMa�÷˜BWi£Uƒ"K®ŒÆ“�2và|lRÁ>,3‚g)��‡gs7¹éZ}1c=…dÛÏz‡¯íHÇˆ‹H_ø‘=õR5›E–Ë"„˜¨AÉP¸.+§‡þDÈa æ÷CÐ¥›*-òh/£ÎýS‰ÇŒ[Gì} /�TAºm:§í˜43™¦ÿÚ�á©v8TžâWˆÜ¼¨b§wEŒù„ó‰™×Éáy5íþž|!åÒÑ§ÀÎHÊŸtâ¦ÇSÏüúÕUD=Îáãµê22KQSÛ2ç—¦Gè>Àò‹eëu!Â_{ü£øñÂç�Ffä�€�¦i†�ÊÍüwRÓÒ‘Çv×ú}6§9˜Xâ#u®€&IOG¥„ºÍ<V•ÌÜÐ“buW¶yÖÿ“ý‰O®é
7¸U�åš¾³SŸâ¸DeÔoŒëÃFŽ¾§Þ,5Í#°íâsA~þa½p8˜&fû3Î´¶É9Ä»8äÇš°”mÊ6éÞ/ìø:”õ,L³ÞßÝOJŽãû×f´Y¼g5Q1EPâÊkÉêzi&·hd}“î®ºâÞFõ{ 4F
vû¨R�ÅsU¤,bZ9,aWùÖTœæå]Â153Åëµè& æO~~‡_*õK%
Æ0hNžŽ&¬}ù…øpÙÙ‡òíbw@´Ä?T·OÜÏ\=€ffGšÉt'ßþ›Ùöý�É»�áÁÛÆn€‚îBÇCN¡q
\ËùïõðwžÖã}ìÉšMçýÔ”êz W�ü†Õ×ö�'9£4‚_¨¤ÿÇÑÿôÊ¡'ré˜½Ysò&–
¸ Ù4ÔE#‡ÙwÝßgØA£´c{?0‘Nj©½œ=Á’�½õî€ŸHrÄcÌ$ÀìN»`|hÊ~ÿØ«œêä}¬myD¸�ë´ÆÙ>Û¡ní·+yh.ü©lqÿ�mp\Y2cpB|zŒË-nßZ{þ{ókWÀeôl=)ùu—Z–ï½™öËëoáÑ’M3§Šˆû�¿»ºs�CîÓ”[þõæ²ùSi1–ó¨¬¤ÐÍ�¬';®>r¶ºÑ8pÙŠúŽÿ›™‹#`ŒÈ£`Lz·ÜÊ�H‚
F/‰ÙA”ûŒ§Ä¡�¢iãJÊ•ÁÅò‡(†KvqØÎu^{¹Kô¡öl““ùœNÌA†25P¿)9‚“2¾
Ó	"¨³1üJ).áÏÊr„cÆ“´ÀiîŠaÞî—˜&Ð]“œ«FPÐøE=–·ÏÑžs<ìÈéÒgû(<duøÞÛ1jw¶ð{$	Fó´à×¾[¢�+[7ç½/–ãï�Ÿ ß�8ÅÍ¸Ú|Ùr¦ÊüvÁÝÍŸ
î—UØ3u¤Ìf4ÿô!X†n“Ü9˜·NøBÞÑjPÒÃñÝÿŒ0'Øã³œ€üÕçg32€ˆ¨E/]\\ÉZ<œ$�ÍJ¦ïÐ©ÕµÐ—ééŠ»8¼ðÍ ôÅæ‚ÒHUs‘yˆàÉø@4ÖiÂ•�„9L‚|B
¶¨>›7—Ê;®kÊÂð,üÞ~ËÛä/£ëvf:!j¼®ZHŠñøs‹hß}”XøÌ)¬Ý9éÙ”IjEhp”	<K—àçÝÜ�-F
Ò8)t¿Ü–¹€ ¸¯AV_!™!$GGÄ ÉŒ>P^ÝQ,ïVi›4ãÔ×ùitNI¥3�šWr�°$ÔS_;
[“œ¿�WNçÅlâoûi?ëMÏûJ²Ë8z#¹‹ûÕ:†éçþ×w‡½²%2¾ý{RÕ[âÖøÐjé¢U‘sòÓ¶½Ž3;ak·ÅqßòtN*¯v¢*@’ÆšòôÞžF8~rëŠò(-Rý—

[5t‡:K7î]ÞõÁÞƒâ•–Q’«iËµ%¥}qV]Ùô5 /v,À™H¶(L\—«zR”‘ðîÐ1Q�0Òs�›s[éÏSª�:ÒüŽfGT)°ÖgüÂKJMÝÔÀ˜l®ª%7Ü]F¶
(rÝÑ�,éAòR²ÍÍT÷.ëŒñ	~:¿U´gQß©™ÈÀFhÌVVö˜ö++Õô€V”€bó<sÃ—Ig�œu{}„™N XÃwÄíº5 ö‰ÞuXÇVý�=(Ž,Þ8•ë_ýÈXx\”S»M|ÿCôwÍ;„Ï)8„9:!ðÓ’ÖkP96–#QÜíè%-àˆÅ`fŽßéIb33à† pï—s/W¢CN�LÉåßÙ£ƒ‚£~îýæðQa{]'¼A™Ä„ò†{žŸ„LÎ°Ê)÷„ š”©
¥+Ä»ª‘wb@Ç¶>s•óVdH‹pÇãÕ5>„ú‘�,žDAQÑÍj6îµD--Æ¼ å–f Tµq5ÆÚÉ¨ã�çh¡!p™òW‘Q P»ùz| {{Ù•GþˆÒ‡·âÖ½½wR>Â>e3*Ÿx}÷õŒ1D¢¼šqådsJñé[‘™éñØHœÎÚŠ¥äÿv1�*¢j;‚}€JÍqÇ¯@Ç�QXƒï8m~žlU–Mîœs8tÐ¯�]šøÔ9ßŠb0amì�›Æ•”RzC4"I×dbmto.W]$ù¢àŸ`'©$(dó}B� p¯´êè‡-kš¾:8_ä~›ÅlµÜãÕõŠµ)¾n›ð“†ö’ûwÓ!&¨-W�nÀæZ»P_’Óh8geÎcû²¿�9²PØ@NU"FZs»9¢¶[^3l5óòyúESöÆi¯'yé¶¸“Yéh>XU÷´Ÿ¢;j³Zÿö–~µ’«úwKcGííÊ|]k¨Âw7{Øw¹N» äß¸e†BöëÑDÞoôfÃ¤uR8M·“\p�ácˆ#îÈ‰kùÛÄ~#”¢ªÝîTOÕ'ïüÙjñÆ¬�iI~¢VáßŠ?òŒ¿P,øƒÈ¦IŒ„=µ8¼A-gæ¤¹æ’|,[ì
´¡˜¡Å¦È&E|b´Ü4›ÈÛxLI;$!ÕäóÖõ©HÅ‚iÄu†6µ=D–'A*áSÖ01æ7a¶{fáë÷øƒÚEˆNI.m¯|>`CŽ.fòŽ`p€eW&‹J•Ó	–s¨Ü=D¦r�vKÅxPœ¡ºü÷–÷,©×³–zÜ‡þeqÛÇŽÞ(–[·Ì’Ô/ÔÂ˜ËZ¦W‡6sOáÍÄÞ˜ŸL`aI¼j	Œ&ßß	¨ºÒAAƒÊôm8Ó¾ÛÃx¯Dãw	2™ÞÀÇ^À¬pö-äÌ+°Eÿ?ƒíÅù~.i@3�«Z£4ÅEœ¹}%ÅgÍCÿßàeÁÉtÖédt
.v+ÿ:<îŒãåpç[f±³Ç›üáŒêÍ{(/d˜=9Æð”õ…¬	ÿÓØgÞ(ÂêëÆ!²‘È×J}GhÅr	Ô�èW¤Pzó†ƒùC2<Ñ»Óv¥¥™×‹%¿+E¼$ysúÄ•ã|œŠâOåôÄÅÂ÷»sŠC% 8®³	~žj€EíK±z—²ÉG²1ÑâwÒ@žþb¹”ÿ§„Iþb5øqE	hý³ÉÒ©m�AÐåáPQ°0Rïgt
9ØŸŠ…š
·�JuÖ