platform-admin/boc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9e4ebeea1aa4679ca00b951fdc58d376419ce821
boc/aamos-ledger-rust/target/debug/deps/liballocator_api2-7b02f80e4eb85c1b.rmeta
T

1370 lines
465 KiB
Plaintext
Raw Normal View History

ARCHITECTURE: NFC roadmap, edge AI, audit logging
2026-06-29 16:24:48 +00:00
rust
A#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁ¤²XctÔ'ÐÓ©z¨ɽÓ-a4945860e1c53b00Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁ‰systemÁ4’»À||SystemÁ4¼»À|”AerrorÁ,¬ð»À|–ðâioÁÅ »À|ª âcautiousÁDÅÌ»serdeÁŒªÌâ InPlaceSeedÁ\ÒλŒ³Îã4¤�„†”…nightlyÁ<绂œÍí alloc_crateÁ·¤globalÁ            
     
alloc_implÁ grow_implÁ allocateÁallocate_zeroedÁ
deallocateÁgrowÁ grow_zeroedÁshrinkÁ 
  
/× AllocatorÁ1Ñ1à1ö1‡1’1¤1by_refÁ9’9Ñ9à9ö9‡9’9¤boxedÁAAAAAAAAAA A
A A A
AAAAAAAAAAAAAAAAAAA A!A"A#A$A%ABoxÁh
h¥h’hˆh‰An¥n’Aq¥q’At¥tæ t
new_uninitÁt
new_zeroedÁtÿ
ttry_newÁttry_new_uninitÁttry_new_zeroedÁA}¥}’}new_inÁ}
try_new_inÁ}
new_uninit_inÁ}try_new_uninit_inÁ}
new_zeroed_inÁ}try_new_zeroed_inÁ}pin_inÁ}into_boxed_sliceÁ‡ }
into_innerÁAŠ¥Šnew_uninit_sliceÁŠnew_zeroed_sliceÁŠtry_new_uninit_sliceÁŠtry_new_zeroed_sliceÁA�¥�’�new_uninit_slice_inÁ�new_zeroed_slice_inÁ�try_new_uninit_slice_inÁ�try_new_zeroed_slice_inÁ�into_vecÁA˜¥˜’˜ä˜writeÁA�¥�’�äA¡¥¡from_rawÁA ¤¥¤’¤ from_raw_inÁ¤into_rawÁ¤into_raw_with_allocatorÁ¤
into_non_nullÁ¤¨¤leakÁ¬'aÁ¤into_pinÁA
¯¥¯’¯ãA ³¥³>A ¥’>¹ A
»’»>½ A¿¥¿’¿ƒ¿†AăAƥƒÆ�ÆØ A˥˒Ëï
ËÃË�ˌˢAÓ¥Ó’Ó‹A×¥×’AڥڒڧݙAߥߒßfinishÁß´
ßwrite_u8Áß write_u16Áß write_u32Áß write_u64Áß
write_u128Áß write_usizeÁßwrite_i8Áß write_i16Áß write_i32Áß write_i64Áß
write_i128Áß write_isizeÁAð¥ð÷Aó¥ó’ó÷A÷¥÷’÷÷Aû’û÷Aþ’þ÷A�¥�’�Ÿ� �ž�ˆ
Aˆ¥ˆŸˆ ˆ÷Œ AŽ¥Ž’ŽŸŽ ŽErrorÁŽª” A–’–downcastÁ˜¥–downcast_uncheckedÁš¥Aœ’œéž¥œ� ¥A ¢’¢é¤¥¢�¦¥A!¨¥¨’¨×A"¬¥¬’¬×A#°¥°’°×A$´¥´’´å´´A%¹¥¹’¹A&½š½’½›½ó ½ size_hintÁ½nthÁ½‹ABoxIterÁśŋA'ȚȒțȋÌsomeÁÍ¥A(ÏšÏ’Ï next_backÁÏnth_backÁA)ÔšÔ’Ô‘A*ؚؒA+ÛšÛùÝ¥A,ߥߒ߃߆A-ä¥ä’äborrowÁA.è¥è’è
borrow_mutÁA/ì¥ì’ìÉA0ð¥ð’ðas_mutÁA1ô¥ô’A2÷—÷’÷°÷Š A3ü’üextendÁþšþ raw_vecÁ���������� �
� � �
��������—‚��š÷�œ÷�ž×� AllocInitÁ 
UninitializedÁ¡
 ZeroedÁ£
�RawVecÁ¥¥¥’¥µ ¥capÁ¥¤�«¥«’�®¥®’�±¥±æ ±
with_capacityÁ±with_capacity_zeroedÁ�¥’MIN_NON_ZERO_CAPÁÛ with_capacity_inÁwith_capacity_zeroed_inÁinto_boxÁ allocate_inÁfrom_raw_parts_inÁµ capacityÁ¨current_memoryÁreserveÁÄdo_reserve_and_handleÁťŒreserve_for_pushÁ try_reserveÁ
reserve_exactÁtry_reserve_exactÁ
shrink_to_fitÁ�ͥ͒Í
needs_to_growÁÍset_ptr_and_capÁÍgrow_amortizedÁÍ
grow_exactÁÍ¤Ô � finish_growÁÖ’Ö Ö � Ú¥Ú’Úã�handle_reserveÁÞ � alloc_guardÁ�capacity_overflowÁÁââââââââââ â
â â â
âââââââââââââââââââ â!â"â#â$âspliceÁˆˆˆˆˆˆˆˆˆˆ ˆ“š“’“›“ó “³ˆ™š™’™Áˆ�š�’ˆ š ’ ãˆ¤¥¤’¤fillÁ§š¤ move_tailÁâ%âdrainÁ«««««««««« «
« « «
««DrainÁ»ø»¥»’»
tail_startÁ»tail_lenÁ»ù»Á«Ã¥Ã’Ã׫ÇøǥǒÇas_sliceÁÇ¨Ç keep_restÁ«ÎøΥΒÎÉ«Ó¥Ó’«Ö¥Ö’«Ù¥Ù’Ù›Ùó Ý Ù³«à¥à’àÁã «å¥å’åãè DropGuardÁé
é'rÁéøé¥é’éˆèðø+ðøð¥ð’ðã«ö¥ö’« ù¥ù’â&âêýýýýýýýýýý ý
ý ý ý
ýýýýýIntoIterÁ�¥�’�bufÁ�phantomÁ�Ë�¤�µ �þý™¥™’™×ý�¥�’�ù)� as_mut_sliceÁ�¨�as_raw_mut_sliceÁý¤¥¤’¤Éý¨¥¨’ý«¥«’ý®¥®’®›®ó ®³®üýµ¥µ’µÁý¹¥¹’ý¼¥¼’ý ¿¥¿’¿ƒý
åÒÃãÆâ+Ç
ÇøǥǒLjÆͥ͒Íãâ
partial_eqÁÑÑÑÑ__impl_slice_eq1Áâset_len_on_dropÁÖ SetLenOnDropÁ×ø×‘× local_lenÁÖÛøÛæ Û
increment_lenÁÖßãâ'âöâ¥â’â€.â‘âç¥çæ ç�çfrom_raw_partsÁâì¥ì’ìÛ ìƒ ìÝ ìinto_raw_partsÁìinto_raw_parts_with_allocÁìþ ì¬!ì“"ì€"ì¨"ìÁ"ì shrink_toÁìÞ
ìtruncateÁìù)ìô.ìas_ptrÁì
as_mut_ptrÁì¨ìset_lenÁì swap_removeÁƒ
assert_failedÁìinsertÁ…¢6ìremoveÁ‡¢6ìretainÁ‰—‰ ì
retain_mutÁŒ—ŒBackshiftOnDropÁŽøŽ¥Ž’ŽÁŽ
processed_lenÁŽ deleted_cntÁŽ original_lenÁŒ–¥–’–㌠process_loopÁš—š¥š’šDELETEDÁŒ Œ ì dedup_by_keyÁ¡—¡œ¡ ìdedup_byÁ¥—¥
FillGapOnDropÁ§ø§¥§’§readÁ§´
§Á¥®ø®¥®’®ãìpushÁìpush_within_capacityÁìpopÁìappendÁìappend_elementsÁì�(¸£ìclearÁì‘ìis_emptyÁì split_offÁ½¢6ì resize_withÁ¿—ììÁøìspare_capacity_mutÁìsplit_at_spare_mutÁìsplit_at_spare_mut_with_lenÁâƥƒÆresizeÁÆextend_from_sliceÁÆextend_from_withinÁË£Ë Ë âÏ¥Ï’ÏŸÏ Ïinto_flattenedÁâ
ExtendWithÁÕ¥Õó Õ‹â
ExtendElementÁÙ
٥وâÝ¥Ýó Ý‹âá¥á’á extend_withÁä–âæ¥æ’ædedupÁé âë¥ë’ëåë´âð¥ð’ðâ ô¥ô’ôƒô†â
ù¥ù’ù§ü™â þ¥þšþ’þ°þÖâ „¥„š„’„×â
‰¥‰ù‹šâ�¥�’�›�à-�êâ“ø“¥“’“›“à-“êâšøš¥š’š›šà-šêâ¡¥¡’¡œ¤šâ¦¥¦’¦•&©£©šâ¬ø¬¥¬’¬œ°šâ²¥²’²ï
⥒⹥¹’¹‹â½¥½’½ãâÁ¥Á>âĥĒÄ×âȥȒÈÉḁ̂̒ÌÊâХВÐÉâÔ¥Ô’ÔÊâØ¥Ø÷âÛ¥Û÷â Þ¥ÞŸÞ Þ÷â â!ä¥ä’ä÷â"è¥è’èŸè è÷í â#ï¥ï’ï÷â$ó÷â%õ¥õ’õŸõ õÃõªû û â from_elem_inÁþ¥þ’â from_elemÁ�¥macrosÁƒÁž………………SliceExtÁ‹¥‹‘‹ to_vec_inÁŽ’‹repeatÁ…‘¥‘ãH“’“â+•ø•¥•’•Á•num_initÁ“›ø›¥›’›ã‘üHuniqueÁ¡UniqueÁ¢¥¢‰ ¢_markerÁ¡¦¥¡¨¥¡ª¥ªð ªØ5ªas_non_null_ptrÁªÉªÊ¡±¥±ƒ¡´¥¡¡¡
unsize_boxÁ collectionsÁºººãaddrÁ¿¥ invalid_mutÁÁ¥ GlobalÁÄ
   ȃ Ê> Ì×
AllocErrorÁÎ
ÒƒÕ�×ÖÙ×�TryReserveErrorÁÛ‚�
݃� � �
âÖ�ä×�TryReserveErrorKindÁæCapacityOverflowÁç
æûLélayoutÁé‡
�ìƒ��ï��ñÖ�ó׈SpliceÁõøõšõ’õ�(õ replace_withÁˆûøûšû’û×Ñ€ ¥€ ¦€ A1Á€ A2Á€ �€ Ø Ñ‡ ¥‡ ¦‡ ’‡ �‡ Ø Ñ� ¥� ¦� ’� �� Ø Ñ“ ¥“ ¦“ ’“ �“ Ø Ñ™ ¥™ ¦™ ’™ �™ Ø ÑŸ ¥Ÿ ¦Ÿ ’Ÿ �Ÿ Ø Ñ¥ ¥¥ ¦¥ ’¥ �¥ Ø Ñ« ¥« ¦« ’« �« Ø Ñ± ¥± ¦± ’± Ÿ± ± �· ± Ø ¹ Ñ » ¥» ¦» ’» Ÿ» » �Á » Ø Ã 




!
"
#
0
0
0
2
3
4
5
6
7
8
9
;
<
=
>
?
@
«
²
Â
Ã
Ã
Å
É
É
Ê
Ê
Î
Î
Ï
Ï
Ð
Ð
Ñ
Ñ
Ò
Ò
Ö
Ö
Ý
Ý
â
ã
ã
ä
å
æ
ç
è
é
ê
ë
ì
í
î
ï
÷
ú
û
ý
«
«
«
¯
¯
¯
³
³
³
¸
¼
Á
Â
Ã
Ò
Ó
×
â
ã
ã
ç
ë
ï
ó
û
û
û
þ
˜
Ÿ
Ÿ
Ÿ
À
Á
Â
Ã
Ä
Å
È
É
Ê
Ë
Ì
Ð
Ñ
Ò
Ó
Ô
Ö
Ý
“
—
˜
™
œ
�
 
£
¤
§
§
©
Ã
Æ
Æ
Æ
Ë
Ì
Ò
Ó
Ö
Ù
Ý
ß
à
ã
å
è
õ
ö
ù
œ
œ
œ
 
¡
¢
£
§
²
³
¸
Â
Æ
Í
Ð
Þ
ß
à
ô
õ
ö
÷
ø
ù
ú
ü
ý
þ
ÿ
€
�
‚
ƒ
…
‡
‰
‰
Œ
Œ
–
™
š
š
š
š
¡
¡
¥
¥
¥
²
³
´
µ


·
¸
º
»
¼
½
¿
Ã
Ä
Å
É
Ê
Ê
Ë
×
ß
ä
é
ï
ó
÷
ø
ø
ü
ü
ƒ
ˆ
¤
©
°
µ
µ
¼
¼
À
Ç
Ç
Ç
Ë
Ï
Ó
×
Ø
Ú
Û
Ý
ó
ô
�
Ž
�
“
Ÿ
 
¯
°
³
É
Í
Í
Í
Ó
Ö
Ö
Ø
Ú
Ú
Ú
Þ
á
á
ã
å
å
å
í
ð
ð
ò
ô
ô
ô
ÿ
ÿ
ÿ
…
…
†
†
‡
‹
‹
‹
Œ
Œ
Œ
�
‘
‘
‘
’
’
’
“
—
—
˜
˜
™
�
�
ž
ž
£
£
¤
¤
©
©
ª
ª
«
¯
¯
°
°
·
·
¹
¹
»
Á
Á
Á
Ã
Ã
Ã
1ÅÕ‹Š ÄÄžL £‰]ÆÔ˜~Û´bØ´b³´b¿c´b1´bŠ ÎÎÏûL :á¤{‹®LgÛ’cØ’cÐì’cµß’c’c™’c¿c’cÄc’c1 8’ÌìhhiˆlˆAm‰A ^†��N-¤¥Žd� �dŒ"�d³hhiˆlˆAm‰A ^†��N-¤Ôd´b³hhiˆlˆAm‰A ^†��N-¤
ÔdŽd³hhiˆlˆAm‰A ^†��N-¤’Ø�dØhhiˆlˆAm‰A ^†��N-¤´bµß�d�díß�d�dº�d™�dše�d¢e�déødÔd鄾„¾PinÁ†¾‰ ˜X$]È=„kt•�d�déhhiˆlˆAm‰A ^†��N-¤
¥’ 8ÝhéhhiˆlˆAm‰A ^†��N-¤Žd 8éhhiˆlˆAm‰A ^†��N-¤
ºf�féhhiˆlˆAm‰A ^†��N-¤óe´bÔdŸðhhiˆlˆAm‰A ^†��N-¤ÔdŸŽd¼eÄc�d¿c�dÎc�dé!�dö!�dùMhhiˆlˆAm‰A ^†��N-¤šŽdÅÙkŒMÙkÃMÙkòPÙkÃLhhiˆlˆAm‰A ^†��N-¤
�l´b�lؼe �dÔd£�dÔdà�dÔdã�dÔd“í�d‚ØhhiˆlˆAm‰A ^†��N-¤—ŽdÐLúHúHßûHÁ‘4Ý­f‰úM÷�fØÛÛÎMÜ‚�ð}£û;™yµÐìÙnµßÙnÙn™Ùn¿cÙnØæçèÁNéûLêæNë‡
ZUVÒ—Ë4kÐì»oµß»o»o™»o¿c»oéÙn»oé»oûØûØüØ LayoutErrorÁ :ð¨?¢©ÄcÙnÌ쥥¥¨µ �©Ë�ª¤�nýGâ@mÔdŽd� ‰qŒ"‰q¿cõõµOù�(âúãOâÙml¶ð™‡žøšähùMõõµOù�(âúãOâÙml¶ð™‡ž8°rähŒMÀrÃMÀrŒ"Àr¿c»»è(¿�)âÀŸ)âÁùâÂÁâÄ­KKtƒLÇ8Þhähà»»è(¿�)âÀŸ)âÁùâÂÁâÄ­KKtƒLÇøÞhähÝh� ªsÌìªsùMªsŒMªsŒ"ªsŒ"ééêâ+ ·p×Ø`Ùëø+ø¥’ÃMªsòPªs¿c��à-“€.┋.â•Ë▤◵ â˜þâš¿ÖN3ÔdŽdàŽvóeÌìŽv� ŽvùMŽvŒMŽvÃMŽvòPŽvØŽvŒ"ŽvŒ"ÇÇÈâ+̈ý ?Ó�L ö!I8Þhähµßââöå€.âæ‘â¨ñ'N-y‚DÔd±Pââöå€.âæ‘â¨ñ'N-y‚D¦»Pµßââöå€.âæ‘â¨ñ'N-y‚DÞhíu 8
¦µß¹y 8þyµßêhââöå€.âæ‘â¨ñ'N-y‚Dÿyíuµß 8Ýh¥zµßââöå€.âæ‘â¨ñ'N-y‚DÔdäh
¥yµßóeââöå€.âæ‘â¨ñ'N-y‚D¥yähµß»¾¿BorrowedÁÀˆÁÂOwnedÁÈ¢ÓÛ?'°UF8Ýh¥zµß�{¥yŸµß¹y 8ÿyŸŒ"×׿2Ù‘ÖÚã2Ö‚û_Ö
g;8Œ"ŽŽ˜7’Áâ“Ï7â”ä7â•÷7âä¨ÓAoqá«8ÞhähŒ"§§®9«Û9⬴
â­Á‴¸ÌÔRRøÞhähÕÙÙÚŽ>܈â S™8ñÔdÔdé!ââöå€.âæ‘â¨ñ'N-y‚DÔdŽdö!ïØïšeïÙ¢�{°r³"�{°rÃLââöå€.âæ‘â¨ñ'N-y‚DÔd´bÔdÇLïÇL øââöå€.âæ‘â¨ñ'N-y‚DÞhähÇL øÉ�ÐLïÔdÐLÉ� øÞhíßïï™ïºïŒ"ï³ï€¿cïàïïãïïàïóeãïóeéââöå€.âæ‘â¨ñ'N-y‚DÞh´bêh麃ízéï€Êjéï¼eéïÚjé¼eïéââöå€.âæ‘â¨ñ'N-y‚Dýi´b¶ið‘kï‹óeÔdŒ"••â+™Á…šÏI…uÎo‚±£ÌøÞhähÌ좢™J¤‰ ¡¥·J¡§2º
PúÔd� ù…Øù…Š ù…ÆÄÐδ¢ÇÄÑÎÈÄÒοhÄhßhÝÛìæ¿�ôâ±¢Êijh¶h»hÁâÌÄÙάhäÛóæûõû™�ÄâÄ9
ÔÎßÛîæÕÎÆhàÛïæ€ â‡ â� â“ 
™ 
Ÿ ⥠ « »± â» â×Î×hâÛñæâ/ΨhžÛnh«¥Ö»¨�¦¢qh®¥Ó»«�¨¢¯hÚ¥ õå»ðéÃ�ÍÇß×–Ž®§½â›•Ëh²âÓh¹âÚhùâßhðhó„¾÷hûhþhˆhšÛœæØâÛâÞâäâèâïhóâŽhõ°h´hëâ¹hðâ½h“õÙ»®�ÈhÏh™õ໵�Ôh�õö»¹�Øhù»¼�Ûh‰âähèhìhλ¤�ÈâÐâðhÌâÔâôh÷hüúH¡â¬âÝÙþâ„â�â“
š
‘ Š ÇÛØ
³C¿c 1>Ðì
µß™ZÄc"Ìì� !Œ" !íßSº
še
¢e
éðdÎc
é!ö!
ùM
ÅŒMÃMòPÃL 
£àã"“í‚ØÐLÕÙ¢³"ÇL‹1Áü•�%´� Ôž�

¬ž�
¬Ôd8- ·�,¼� ü‘�1 hÔdŽd Á� È� Ç�üÈŒ€§�d$‚� Ôd茎d,õŒù…úå‘øŽd±@-¤0n$¸² Žd Á²²«ü‡²; Žd«² �d ž²Š“m­>0Á0Á4‡% Ĥú$
 dú$
ºÔd´b>- �%”%³üÕ$?¥¥¥¨µ �©Ë�ª¤�nýGâ@mÔd´b$ë$´bÄg Äå/œå/
Ό/
ÀÔd+7 ü/Y$ ˆ0
üâ/zRܘ0œ˜0
Œ˜0í•&2$¯0T ²0 ¾0
ü•0G0 Õ0
. Û0×ü·/¦¹,Ú/––

D_Áœî2
Δ2
“Ôd,,£3üÖ2] ¥ÔdŽd ”3 ²3¹3 ¸3üß1Úº‰q$€2Žd,ó1‰‰§‹‰ ïíe¼îËè¿*ÔdŽdÙ¤Iylßc
\ßc
³Ôd+üÈcC âÔd´b ÿc Šd‘déü£cnï€$¹cà”“ ¬ìš,ûš 
$tìš
ºÔdŽd8J €›üÕšK âÔdŽd ”› Ÿ›¦›ü¥š�ïï$ÆšŽd,¹š‰qÒŽdФMfalseÁtrueÁÜìƒ
"´ì
žÔd3C †\¢ • ÔdüÊr ¢Ôd »Ì¬ü¯�ù…$áå‘ÑâšÌå‘Ì• • – PhantomDataÁFu\»ŸÔd½µ Txdƒâš¬ƒ
 4�
ªÔd9D� —ž­üÕIå‘4òù…$éâš„6dââšô®ü§MâšTÍù…$Ä .ìÄÜÆlÇ$Ç
#4Ì
­Ôd3DÌ W Ôd Óu–¤ à”¡ èé¯ü™Ð Ôd¾ ù…,´†¥÷–¤÷–¤ÿå‘ùù…ù3\üð30 hÔdŽd!i-�d8ù…@ŽdGNü¼)) éçuíu#ê0ééêâ+ ·p×Ø`Ùëçuíut »»è(¿�)âÀŸ)âÁùâÂÁâÄ­KKtƒLÇçuíuÕÜüî&% ÇÞhäh!È.ÇÇÈâ+̈ý ?Ó�L ö!IÞhähp ��à-“€.┋.â•Ë▤◵ â˜þâš¿ÖN3Þhähçî¼¹¤ ÙÔdÚ)°4Ôd;Bí¯\~Á‡
„ÔKTž
¹¤,
ÃÁ1
âÃÃHD•‹Ãä,ÒAÃåK\ȺÃüáúÌ allocator-api2 crate.ÁúíܯÜÁÛ„ÔKÙ¹¤×ÃÁÖâÃÃHÕ‹ÃäÓAÃåKѺÃfilüh!cTº»‚œ–¬•üŒ 4¾A�⃅¡º¾¿ÁÃHP‹¬ˆal Ô Memory allocation APIsÁ,¨ 1ÎÏ×, `µ $;“
§<A‰ �\±­‚% 4¾èØ&Ôo\ÆûØ'¾L4…Ä(¾LÅ(¤,ü �*§dƒ †+˜<‘ ‚,ã <š „-handle_alloc_errorÁ”ý œ.$ õ÷Ä ê5ÝßTi»¤ŒUÌO4mÄŧ< ‰ 
¤,2 � §d9 † ˜<G ‚ ã <P „ ã4o ¾  L\w Á ûLT’ Î ûLÏ èLž 1  4© èØ &” Í” À²´¤¦–˜l_ ‹�},Š suQSCE\í ´bü•W T˜  Å  Å ´bèØèØ éØ™²‚êØŸ²‚ªë¥CHÈÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
‰‰§‹‰ ïíe¼îËè¿*üi’c £ 
$¤ æN4ª zeroedÁ4º üš  L¤  Æ  Æ ´b‰‰§‹‰ ïíe¼îËè¿*ýiݳݳ�´ · 
$¸ µ Æ 
old_layoutÁTà 
new_layoutÁTü Æ´4˜
üï ´b !"#234567!#" ü¬G D¯ Ç  Ç ´bݳ�´ ¸ 
$¹ æN4¿ ü¾N |Á È  È ´bݳ�´ Ñ 
$Ò æN4Ø üÖ= Tà É  É ´b„¶ݳ ë 
$ì µ ò æN4„ üˆ"› $’" Ê  Ê ´b„¶ݳݳ�´  " 
!$¡" µ ¯" æµTÉ" øµTå" üÌ$¢ \Ö$ Ë  Ë ´b„¶ݳݳ�´ ë$ 
"$ì$ µ ú$ æµT”% øµT°% ü–'� 4 ' Ì  Ì ´b„¶ݳݳ�´ °' 
#$±' µ ¿' æµTÙ' øµTõ' \£«®Ÿ¢“–¤÷‹”çpsehZ]ORüé&7ü� ’c0Åc0ü·8ºÍ Î Ï  Í ’c Î  c cˆ¢cµ
 `£c€. `àB¤GS
Ï Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ Èà O˜éBL/ ¾/
0$¿± ÅÔ×ü«c` An implementation of `Allocator` can allocate, grow, shrink, and deallocate arbitrary blocks ofÁü� $! data described via [`Layout`][].Á´ úü¸ c` `Allocator` is designed to be implemented on ZSTs, references, or smart pointers because havingÁüœ
^[ an allocator like `MyAlloc([u8; N])` cannot be moved, without updating the pointers to theÁ¬û
 allocated memory.Á‘ úü• a^ Unlike [`GlobalAlloc`][], zero-sized allocations are allowed in `Allocator`. If an underlyingÁü÷ UR allocator does not support this (like jemalloc) or return a null pointer (such asÁüÍ ?< `libc::malloc`), this must be caught by the implementation.Á�
úü‘
" ### Currently allocated memoryÁ´
úü¸
c` Some of the methods require that a memory block be *currently allocated* via an allocator. ThisÁ|œ means that:Á¬úü°fc * the starting address for that memory block was previously returned by [`allocate`], [`grow`], orÁ¬— [`shrink`], andÁ­úü±a^ * the memory block has not been subsequently deallocated, where blocks are either deallocatedÁü“_\ directly by being passed to [`deallocate`] or were changed by being passed to [`grow`] orÁüóa^ [`shrink`] that returns `Ok`. If `grow` or `shrink` have returned `Err`, the passed pointerÁ¤Õ remains valid.Áêúüî%" [`allocate`]: Allocator::allocateÁì” [`grow`]: Allocator::growÁü²! [`shrink`]: Allocator::shrinkÁüÔ)& [`deallocate`]: Allocator::deallocateÁþú´‚ ### Memory fittingÁ™úü�a^ Some of the methods require that a layout *fit* a memory block. What it means for a layout toÁüÿb_ "fit" a memory block means (or equivalently, for a memory block to "fit" a layout) is that theÁüâ# following conditions must hold:Á†úüŠTQ * The block must be allocated with the same alignment as [`layout.align()`], andÁßúüãQN * The provided [`layout.size()`] must fall in the range `min ..= max`, where:ÁüµUR - `min` is the size of the layout most recently used to allocate the block, andÁü‹\Y - `max` is the latest actual size returned from [`allocate`], [`grow`], or [`shrink`].Áèúüì%" [`layout.align()`]: Layout::alignÁü’# [`layout.size()`]: Layout::sizeÁúdº # SafetyÁÇúüËc` * Memory blocks returned from an allocator must point to valid memory and retain their validityÁü¯;8 until the instance and all of its clones are dropped,ÁëúüïZW * cloning or moving the allocator must not invalidate memory blocks returned from thisÁüÊLI allocator. A cloned allocator must behave like the same allocator, andÁ—úü›_\ * any pointer to a memory block which is [*currently allocated*] may be passed to any otherÁôû method of the allocator.Ášúüž85 [*currently allocated*]: #currently-allocated-memoryÁLè11Îìü×íb1ü×ü×234567823456785378642ü½%Hüø+( Attempts to allocate a block of memory.Á¨úü°kh On success, returns a [`NonNull<[u8]>`][NonNull] meeting the size and alignment guarantees of `layout`.Á úü¨_\ The returned block may have a larger size than specified by `layout.size()`, and may or mayÁüŒ&# not have its contents initialized.Á·úd¿ # ErrorsÁÐúüØWT Returning `Err` indicates that either memory is exhausted or `layout` does not meetÁü´ .+ allocator's size or alignment constraints.Áç úüï `] Implementations are encouraged to return `Err` on memory exhaustion rather than panicking orÁüÔ!]Z aborting, but this is not a strict requirement. (Specifically: it is *legal* to implementÁü¶"^[ this trait atop an underlying native allocation library that aborts on memory exhaustion.)Á™#úü¡#]Z Clients wishing to abort computation in response to an allocation error are encouraged toÁüƒ$`] call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.Áè$úüð$HE [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.htmlÁDÀ%Ð  Ð „Øݳ�´1 É%1
2„Ø$Ê%æN4Ð%
returned.Á¶Lúü¾LSP The memory block will contain the following contents after a successful call toÁ”–M `grow_zeroed`:Áü­MPM * Bytes `0..old_layout.size()` are preserved from the original allocation.Áü‚N\Y * Bytes `old_layout.size()..old_size` will either be preserved or zeroed, depending onÁüãN]Z the allocator implementation. `old_size` refers to the size of the memory block priorÁüÅOXU to the `grow_zeroed` call, which may be larger than the size that was originallyÁü¢P(% requested when it was allocated.ÁüÏPZW * Bytes `old_size..new_size` are zeroed. `new_size` refers to the size of the memoryÁü®Q1. block returned by the `grow_zeroed` call.ÁäQúdìQçÑýQúü…RUÞïüßRb½ðüÆSO©ñšTúü¢TPŽò÷TúüÿT8©Öä¼UýæÝUúdåUËÚöUúüþUT´óü×V@’ôœWúü¤W`’Üü‰X]üÜüëX^ãÝÎYúüÖY]×Þü¸Z`¾ß�[úü¥[H´à\’\Ô  Ô „Ø„¶ݳݳ�´1 §\1
6„Ø$¨\µ ¶\æµTÐ\øµTì\ü­u�ü›d(% Attempts to shrink the memory block.ÁÈdúüÐdfÎèü»e]¾éü�f\Y this, the allocator may shrink the allocation referenced by `ptr` to fit the new layout.Áþfúü†gY—ëüägaúëüÊhXU allocation was shrunk in-place. The newly returned pointer is the only valid pointerÁü§i"ÆíÎiúüÖi`þíü»jGèî‡kúd�kçÑ kúü¨kUÞïü‚lb½ðüélOL * `new_layout.size()` must be smaller than or equal to `old_layout.size()`.Á½múüÅmPŽòšnúü¢n8©Öäßnýæ€oúdˆoËÚ™oúü¡oT´óüúoB? constraints of the allocator, or if shrinking otherwise fails.ÁÁpúüÉp`’Üü®q]üÜü�r^ãÝórúüûr]×ÞüÝs`¾ßÂtúüÊtH´à4·uÕ  Õ „Ø„¶ݳݳ�´1 Çu1
7„Ø$Èuµ ÖuæµTðuøµTŒvüñ~8ü²}FC Creates a "by reference" adapter for this instance of `Allocator`.Áý}úü…~QN The returned adapter also implements `Allocator` and will simply borrow this.Á4ô~Ö  Ö „Ø…‹1 û~1Íì„Ø,£
8„Ø$ü~üÆ@8× ’::× ÎìŽd Ò1ŽdLó‰d;<=>?@234567;><@?=EGü£€GD¦€Ø  Ø ‰dݳ�´9 ¯€9
;8Žd$°€æN4¶€ü°�N|³�Ù  Ù ‰dݳ�´9 Ã�9
<8Žd$Ä�æN4Ê�üË‚=TÕ‚Ú  Ú ‰d„¶ݳ9 à‚9
=8Žd$Ⴕ ç‚æN4ù‚ü¤„›$®„Û  Û ‰d„¶ݳݳ�´9 ¼„9
>8Žd$½„µ Ë„æµTå„øµT�…ü冢\ï†Ü  Ü ‰d„¶ݳݳ�´9 „‡9
?8Žd$…‡µ “‡æµT­‡øµTɇü´‰�4¾‰Ý  Ý ‰d„¶ݳݳ�´9 Ή9
@8Žd$ωµ ݉æµT÷‰øµT“ŠlÊü*' The `Box<T>` type for heap allocation.Á+úü/NK [`Box<T>`], casually referred to as a 'box', provides the simplest form ofÁü~MJ heap allocation in Rust. Boxes provide ownership for this allocation, andÁüÌNK drop their contents when they go out of scope. Boxes also ensure that theyÁü›0- never allocate more than `isize::MAX` bytes.ÁÌútÐ # ExamplesÁßúüãB? Move a value from the stack to the heap by creating a [`Box`]:Á¦ú<ª ```Á¤² let val: u8 = 5;ÁüÇ'$ let boxed: Box<u8> = Box::new(val);Á<ﾕ÷úüûEB Move a value from a [`Box`] back to the stack by [dereferencing]:ÁÁú<ž•üÍ%" let boxed: Box<u8> =
TQ for a `Cons`. By introducing a [`Box<T>`], which has a defined size, we know howÁÜŒ  big `Cons` needs to be.Á¨ úœ¬  # Memory layoutÁÀ úüÄ NK For non-zero-sized values, a [`Box`] will use the [`Global`] allocator forÁü“ LI its allocation. It is valid to convert both ways between a [`Box`] and aÁüà GD raw pointer allocated with the [`Global`] allocator, given that theÁü¨
OL [`Layout`] used with the allocator is correct for the type. More precisely,Áüø
KH a `value: *mut T` that has been allocated with the [`Global`] allocatorÁüÄGD with `Layout::for_value(&*value)` may be converted into a box usingÁüŒPM [`Box::<T>::from_raw(value)`]. Conversely, the memory backing a `value: *mutÁüÝHE T` obtained from [`Box::<T>::into_raw`] may be deallocated using theÁü¦=: [`Global`] allocator with [`Layout::for_value(&*value)`].ÁäúüèNK For zero-sized values, the `Box` pointer still has to be [valid] for readsÁü·KH and writes and sufficiently aligned. In particular, casting any alignedÁüƒMJ non-zero integer literal to a raw pointer produces a valid pointer, but aÁüÑMJ pointer pointing into previously allocated memory that since got freed isÁüŸOL not valid. The recommended way to build a Box to a ZST if `Box::new` cannotÁüï1. be used is to use [`ptr::NonNull::dangling`].Á¡úü¥EB So long as `T: Sized`, a `Box<T>` is guaranteed to be representedÁüëB? as a single pointer and is also ABI-compatible with C pointersÁü®B? (i.e. the C type `T*`). This means that if you have extern "C"ÁüñC@ Rust functions that will be called from C, you can define thoseÁüµFC Rust functions using `Box<T>` types, and use `T*` as correspondingÁüüC@ type on the C side. As an example, consider this C header whichÁüÀA> declares functions that create and destroy some kind of `Foo`ÁT‚ value:Á�úD‘ ```cÁ”š /* C header */Á­úü±)& /* Returns ownership to the caller */ÁôÛ struct Foo* foo_new(void);ÁúúüþGD /* Takes ownership from the caller; no-op when invoked with null */ÁüÆ! void foo_delete(struct Foo*);Á<辕ðúüôJG These two functions might be implemented in Rust as follows. Here, theÁü¿IF `struct Foo*` type from C is translated to `Box<Foo>`, which capturesÁü‰FC the ownership constraints. Note also that the nullable argument toÁüÐOL `foo_delete` is represented in Rust as `Option<Box<Foo>>`, since `Box<Foo>`Áœ  cannot be null.Á´ú<¸¾•tÀ #[repr(C)]ÁœÏ pub struct Foo;Áãú„ç
#[no_mangle]Áüø-* pub extern "C" fn foo_new() -> Box<Foo> {Á¬¦ Box::new(Foo)Á,¼Æ™Âú„ÆÒ´ü×85 pub extern "C" fn foo_delete(_: Option<Box<Foo>>) {}Á<�¾•˜úüœNK Even though `Box<T>` has the same representation and C ABI as a C pointer,ÁüëMJ this does not mean that you can convert an arbitrary `T*` into a `Box<T>`Áü¹LI and expect things to work. `Box<T>` values will always be fully aligned,Áü† LI non-null pointers. Moreover, the destructor for `Box<T>` will attempt toÁüÓ KH free the value with the global allocator. In general, the best practiceÁüŸ!HE is to only use `Box<T>` for pointers that originated from the globalÁtè! allocator.Á÷!úüû!>; **Important.** At least at present, you should avoid usingÁüº"B? `Box<T>` types for functions that are defined in C but invokedÁüý"EB from Rust. In those cases, you should directly mirror the C typesÁüÃ#A> as closely as possible. Using types like `Box<T>` where the CÁü…$DA definition is just using `T*` can lead to undefined behavior, asÁüÊ$A> described in [rust-lang/unsafe-code-guidelines#198][ucg#198].ÁŒ%úü�%$! # Considerations for unsafe codeÁµ%úü
±Ý´bŠŠ
ŒÔd‘û™üÞŸAüîšMJ Constructs a new boxed slice with uninitialized contents, with the memoryÁüÀ› òÝå›úüí›S¨ÞœÅœ„ßÝœútåœÔøœú<€�¾•ÜŒ�çج�úü´�30 let values = Box::<[u32]>::new_zeroed_slice(3);Áüì�1. let values = unsafe { values.assume_init() };Á¢žúüªž" assert_eq!(*values, [0, 0, 0])Á<Ñž¾•Ýžúüåž&›áùÖ´šŸÄ™Ÿü�Ÿ#.\¸Ÿ„åŸÒ›ŠŠ
�Ôd‘öŸü„¦Yüð QN Constructs a new boxed slice with uninitialized contents. Returns an error ifÁÄÆ¡ the allocation failsÁã¡útë¡Ôþ¡ú<†¢¾•ü’¢*ÅìÁ¢úüÉ¢<9 let mut values = Box::<[u32]>::try_new_uninit_slice(3)?;ÁÌŠ£É—ü¨£#úÙüУ(ü—üý£(¯˜üª¤(â˜äפ¡™4ø¤‚Ûƒ¥úü‹¥# assert_eq!(*values, [1, 2, 3]);Áü³¥*æé<⥾•¤‹¦Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ò›’cŠŠ
ŽÔd‘ ¦üìYüž§MÄ›üð§IF being filled with `0` bytes. Returns an error if the allocation failsÁ¾¨úüƨS¨Þœž©„߶©út¾©ÔÑ©ú<Ù©¾•üå©*Å씪úüœª85 let values = Box::<[u32]>::try_new_zeroed_slice(3)?;ÁüÙª1ä��«úü—«# assert_eq!(*values, [0, 0, 0]);Áü¿«*æé<•ú«úü‚¬&›á¤Ê¬Ö¤ŠŠ
�Ôd‘߬üÛ­!¥‘’’‘’ÈÕ à­æÑ ã­�ŒLæ­¼e“”•–—)+-/üɳQüƒ®WT Constructs a new boxed slice with uninitialized contents in the provided allocator.Áß®útç®Ôú®ú<‚¯¾•üŽ¯*Å콯úÜů°õå¯úüí¯EB let mut values = Box::<[u32], _>::new_uninit_slice_in(3, System);Á·°úÌ¿°É—üÝ°#úÙü…±(ü—ü²±(¯˜üß±(☌²ú䔲¡™4µ²‚ÛÀ²úüȲ"ã™<ï²¾•ùÖ´…³Ä„³üû²#.\£³œÐ³ŽdhhiˆlˆAm‰A ^†��N-¤‰œŽd��
“ÔdŽd‘䳤,ð³ü½ºQüî´WT Constructs a new boxed slice with uninitialized contents in the provided allocator,Áüʵ0- with the memory being filled with `0` bytes.Áÿµúü‡¶S¨Þœß¶„ß÷¶útÿ¶Ô’·ú<š·¾•ü¦·*ÅìÕ·úÜÝ·°õý·úü…¸A> let values = Box::<[u32], _>::new_zeroed_slice_in(3, System);Áü˸1ä��¹úü‰¹"­ž<°¹¾•¼¹úüĹ&›áùÖ´ù¹Äø¹üï¹#.\—ºœÄºŽdÁ®��
”ÔdŽd‘غ¤,äºüÆÁ{üé»kh Constructs a new boxed slice with uninitialized contents in the provided allocator. Returns an error ifÁÌÙ¼ the allocation fails.Á÷¼útÿ¼Ô’½ú<š½¾•ü¦½*ÅìÕ½úÜݽ°õý½úü…¾JG let mut values = Box::<[u32], _>::try_new_uninit_slice_in(3, System)?;ÁÌԾɗüò¾#úÙüš¿(ü—üÇ¿(¯˜üô¿(â˜ä¡À¡™4ÂÀ‚ÛÍÀúüÕÀ#ù¢üýÀ*æé<¬Á¾•¼ÍÁŽdÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Á®’c��
•ÔdŽd‘îÁ¤,‚ÂüáË€üóÅgd Constructs a new boxed slice with uninitialized contents in the provided allocator, with the memoryÁüßÆJG being filled with `0` bytes. Returns an error if the allocation fails.Á®Çúü¶ÇS¨ÞœŽÈ„ߦÈút®ÈÔÁÈú<ÉȾ•üÕÈ*Åì„Éú܌ɰõ¬Éúü
,”áüõá"øáæ ç  æ �d ç �dÆ ûáÆ
ÊÔdŽd$üá¹
,‚âüÌâC¥Ì’ÍÌÍÖÑ ÑâæÑ éâíßÔdÔdTÝâ�ŒLìâ�dÎÏÐÑÒïßðßñßóßòßÒÎÐÑÏjlnpü¬ã7\¯ãè é  è �d é �dÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¿ßÀßÁßLessÁÂßÃßÄß~ÅßÆßÇßGreaterÁÈßåºÝÈnûê7Ë »ãË
ÎÔdŽd$¼ã¹
,Âãü¹ä"¼äê ë  ê �d ë �dË ¿äË
ÏÔdŽd$Àä¹
,Æäü¨å"«åì í  ì �d í �dË ®åË
ÐÔdŽd$¯å¹
,µåü—æ"šæî ï  î �d ï �dË �æË
ÑÔdŽd$žæ¹
,¤æü†ç"‰çð ñ  ð �d ñ �dË ŒçË
ÒÔdŽd$�ç¹
,“çüÞç5¥Ô’ÕÕÔÖÑ ãçæÑ ôçºÔdïç�ŒL÷ç�dÖ»Ö579;ü°è'³èò ó  ò �d ó �d›ºÓ ·èÓ
ÖÔdŽd$¸è¹
,¾èü‡é3¥Ø’ÙØÙÖÑ ŒéæÑ œé™Ôd˜é�ŒLŸé�d*,.0ü¿é7¥Û’ÜÜÛÖÑ ÄéæÑ ÖéšeÔd$Ðé�ŒLÙé�dÝ›eÝ579;ü“ê($–êô õ  ô �d õ ™Ú™ÞÞ ¦êÚÍìÄà ›ê¢eÄÃ4žê
ÝÔdŽdÄÃ$§êº,­ê68üåê;¥à’ááàÖÑ êêæÑ þê¢eÔd4öê�ŒL�ë�dâãäåæçèéêëìíîï£e¤e¥e¦e§e¨e©eªe«e¬e­e®e¯e°eèäëïçãîêæâíéåìÄÆÈʼ½ë4Àëö  ö �dß Çëß
âÔdŽd$Èëü‘ì!,”ì÷ ø  ÷ �d ø üiß šìß
ãÔdŽd$ŸìbytesÁ,¥ììóìDöìù  ù �dýiß ÿìß
äÔdŽd$„í´ ŠíüÐíLÓíú  ú �dß Ýíß
åÔdŽd$âí´ èíü°îL³îû  û �dß ½îß
æÔdŽd$Âî´ Èîü�ïL“ïü  ü �dß �ïß
çÔdŽd$¢ï´ ¨ïüðï!Tóïý  ý �dß þïß
èÔdŽd$ƒð´ ‰ðüÓð#\Öðþ  þ �dß âðß
éÔdŽd$çð´ íðì¹ñD¼ñÿ  ÿ �dß Åñß
êÔdŽd$Êñ´ Ðñü–òL™ò€
 €
�dß £òß
ëÔdŽd$¨ò´ ®òüöòLùò�
 �
�dß ƒóß
ìÔdŽd$ˆó´ ŽóüÖóLÙó‚
 ‚
�dß ãóß
íÔdŽd$èó´ îóü¶ô!T¹ôƒ
 ƒ
�dß Äôß
îÔdŽd$Éô´ Ïôü™õ#\œõ„
 „
�dß ¨õß
ïÔdŽd$­õ´ ³õÔŒöùÖ´òõÄñõüèõ#¥ññÈÕ ‘öødòëò¬ñøü­ö" Converts a `T` into a `Box<T>`ÁÔöúüÜö63 The conversion allocates on the heap and moves `t`ÁÜ—÷ from the stack into it.Á·÷út¿÷ÔÒ÷ú\Ú÷ ```rustÁtê÷ let x = 5;Áäý÷ let boxed = Box::new(5);Ážøúü¦ø$! assert_eq!(Box::from(x), boxed);Á<Ïø¾•$ôøÔdødðð
òÔd¿ ùøü¦ùV¥ô’õôõÖÑ «ùæÑ ¶ù�ŒL¹ùŒ‘<ôùågöëö.024ü¨ÿ!üƒúWå—üßú=ǘ¡ûúü©ûG�‘õûúüýû1. This is also available via [`Box::into_pin`].Á³üúü»ü[X Constructing and pinning a `Box` with <code><Pin<Box\<T>>>::from([Box::new]\(x))</code>Áü›ýIךüéýSP This `From` implementation is useful if you already have a `Box<T>`, or you areÁüÁþL…œ$«ÿ�dågóó
öÔdŽdä,°ÿü–€@ùÖ´üÿÄûÿüòÿ#8…
¥ø’ùù…
øÍìÞh ›€Íìäh ¤€Š Þh$ž€1ähL§€³äh<³€¦húëúSUOQü£„#üÝ€'$ Converts a `&[T]` into a `Box<[T]>`Á‰�úü‘�)& This conversion allocates on the heapÁü¿�41 and performs a copy of `slice` and its contents.Áø�út€‚Ô\“‚×Óü£‚>; // create a &[u8] which will be used to create a Box<[u8]>Áüæ‚2/ let slice: &[u8] = &[104, 101, 108, 108, 111];Áü�ƒ2/ let boxed_slice: Box<[u8]> = Box::from(slice);ÁÔƒúü܃  println!("{boxed_slice:?}");Á<�„¾•$¦„†
 †
Ýh¦h÷ ²„÷
ú8Þhähž,«„üé†7ùÖ´Ï†ÄΆüņ#8‡
’ü‡
üæÑ î†�ŒLñ†ͧ<ý†úhýëý%'üщü§‡'$ Converts a `&str` into a `Box<str>`ÁÓ‡úüÛ‡)�Üü‰ˆ and performs a copy of `s`.Á­ˆútµˆÔȈú\Ј×Óüàˆ-* let boxed: Box<str> = Box::from("hello");ÁÄ’‰ println!("{boxed}");Á<¯‰¾•$Ô‰ˆ
 ˆ
úhû ܉û
ý8Žd¾ Ù‰ü•‹5’ÿÿô¨ š‹…©L�‹Åi€ë€ü²�üÑ‹,) Converts a `Box<str>` into a `Box<[u8]>`Á‚ŒúüŠŒG�‘ÖŒútÞŒÔ\ñŒ×Óü��A> // create a Box<str> which will be used to create a Box<[u8]>ÁüÇ�-µâüù�0- let boxed_str: Box<[u8]> = Box::from(boxed);Á®Žúü¶Ž>�ÝüùŽ2æÝü°�'$ let boxed_slice = Box::from(slice);ÁÜ�úüä�'$ assert_eq!(boxed_slice, boxed_str);Á<��¾•$µ��fÅiþþ
€ºf¾ º�üÖ‘4¥‚’ƒŸ„‚„ƒÈÕ Û‘æÑ Þ‘Ÿtì‘�ŒLá‘Új†‡/1351 ò‘ü§’$,®’Új¼e��
†ÔdŽdŸ­ ´’üÅ“BDÌ“Újï���ŒLý“
‡ÔdŽdŸ$Õ“üÔ•1ùÖ´º•Ĺ•ü°•#¥‰ŸŠ‰ŠÈÕ Ù•ŸtÜ•�jŒëŒ"$ â•ü°˜"üŒ–)& Converts a `[T; N]` into a `Box<[T]>`Áº–úü–C@ This conversion moves the array to newly heap-allocated memory.ÁŠ—út’—Ô¥—ú\­—×Óü½—-* let boxed: Box<[u8]> = Box::from([4, 2]);ÁÔï— println!("{boxed:?}");Á<Ž˜¾•$³˜Êj�jˆˆ
ŒÔdŸÇ,¸˜ü‚™M¥�’�Ÿ‘�‘�ÈÕ ‡™æÑ Š™‹êt˜™�ŒL�™Új“”òó”579;= ž™TÖ™,Û™ŽŽ¼eü»œBüõ™:7 Attempts to convert a `Box<[T]>` into a `Box<[T; N]>`.Á´šúü¼š96 The conversion occurs in-place and does not require aÁÔúš new memory allocation.Á™›úd¡›ËÚ²›úüº›63 Returns the old `Box<[T]>` in the `Err` variant ifÁüõ›+( `boxed_slice.len()` does not equal `N`.ÁD¾œ¼eÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÚjÚj¼eòŽŽ
”ÔdŽdŸÀ\Çœüöž"’——ô¨ ûž…©LþžhhiˆlˆAm‰A ^†��N-¤ì%ºf˜šXZü¦£8üŸŸ30 Attempt to downcast the box to a concrete type.ÁןútߟÔòŸú<úŸ¾•´†  use std::any::Any;Á¡ úü© -* fn print_if_string(value: Box<dyn Any>) {ÁüÛ 85 if let Ok(string) = value.downcast::<String>() {Áü˜¡>; println!("String ({}): {}", string.len(), string);ÁLÛ¡ý ,é¡Æ™ó¡úüû¡.+ let my_string = "Hello World".to_string();Áü®¢)& print_if_string(Box::new(my_string));ÁüÜ¢# print_if_string(Box::new(0i8));Á<„£¾•D­£èõÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
hhiˆlˆAm‰A ^†��N-¤Þhºfèõ–¥™™–¸Û ¶£ì%Þh¹£
˜ºfÞh$¾£(*üÛ©;üó¤)& Downcasts the box to a concrete type.Á¡¥úü©¥,) For a safe alternative see [`downcast`].ÁÚ¥útâ¥Ôõ¥ú<ý¥¾•ü‰¦# #![feature(downcast_unchecked)]Á±¦ú´¹¦ÄöÔ¦úüܦ,) let x: Box<dyn Any> = Box::new(1_usize);Á�§úd•§©áü¦§85 assert_eq!(*x.downcast_unchecked::<usize>(), 1);Á,ã§Æ™<í§¾•ù§úd�¨çÑ’¨úüš¨@= The contained value must be of type `T`. Calling this methodÁüߨ41 with the incorrect type is *undefined behavior*.Á˜©úü ©  [`downcast`]: Self::downcastÁ”é©èõêû–¥››–¸Û ü©Ôüÿ©
šºfÞh$„ª!#üí«)’��ô¨ ò«…©Lõ«hhiˆlˆAm‰A ^†��N-¤ì%Ììºfž ^`ü«°8ü�¬3
Š
‹
 ‰
�d Š
 c cˆ¢cµ
 `£c€. `àB¤GS
‹
²¾¨ ®Ç¨
«ÔdŽd$¯Ç± µÇü‘ÈC¥­’®­®ÖÑ –ÈæÑ ®È¿cÔdT™È�ŒL±È�d¯Àc¯579;üñÈ8ôÈŒ
�
Ž
 Œ
�d �
 c cˆ¢cµ
 `£c€. `àB¤GS
Ž
²¾¬ øȬ
¯ÔdŽd$ùȱ ÿÈüÙÉ8¥±’²±²ÖÑ ÞÉæÑ éÉ�ŒLìÉ�d³Ïc³%')+ü®Ê8±Ê�
�
‘
 �
�d �
 c cˆ¢cµ
 `£c€. `àB¤GS
‘
²¾° µÊ°
³ÔdŽd$¶Ê± ¼ÊüËÌ1¥µ’µÖÑ ÐÌæÑ ÛÌ�ŒLÞÌ�d·¸ê!ë!¸,.02\ƒÍ4ˆÍ´´Ôd¬¯Í,²Í’
 ’
�d ’
Ôd´ ¸Í´
¸ÔdŽd$¹ÍüóÍ4¥º’»º»ÖÑ øÍæÑ ƒÎ�ŒL†Î�d¼÷!¼%')+üÄÎ!LÇΓ
 “
�d “
Ôd¹ Ñι
¼ÔdŽd$ÖÎü”Ï?š¾’¿¿¾Îì�l ™ÏæÑ ¯ÏùM�lDœÏ�ŒL²ÏÙkÀÁÂÃÄúMûMÿM�NƒNÄÂÃÁ]_acLÚÏ$ßϽ½�lúMüŠÐ%$�Д
 ”
ÙkÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ顽 ’н
Á�lŽd$—ÐüëÐ-LîЕ
 •
ÙkÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ½ øн
Â�lŽd$ùÐüÙÑ.ÜÑ–
 –
Ùk¦¢½ àѽ
Ã�lŽd$åѹ ëÑüÃÒ $ÆÒÙk¦¢½½
Ä�lŽd$ËÒl‹Ó<‘ÓAÅÅü×ü‹ÓIÅü×ü× ÆÇÆÇÍì„ØÆTŸÓʦ ÇLŸÓ$¤ÓAÅÅü®Ó$$±ÓA„ØÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÒ¦ÅÅ
Ç„Ø$¶ÓüÖÓ>šÉ’ÊÊÉΠ ÛÓæÑ ñÓè DÞÓ�ŒLôÓÙkËÌÆÇÌ579;L›Ô$ ÔAÈÈé¡üËÔ $ÎÔAÙk¦¢ÈÈ
Ì�lŽd$ÓÔü�Õ+$“ÕAÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÔdÔd¦ª¥ÎÎÈÕ ˜Õ
ÍÔd ›Õà ©Õ ü„ÖUšÐ’ÑÐÑΠ ‰ÖæÑ ªÖŒM�lœŒÖ�ŒL­ÖÙkÒÓ�M�MÒÓ@BDFüöÖ*LùÖ—
 —
Ùk¦¢Ï ƒ×Ï
Ò�lŽd$ˆ×üà×3Dãט
 ˜
Ùk¦¢Ï ì×Ï
Ó�lŽd$ñ×¹ ÷×ü¼ØQšÕ’ÖÖÕΠ ÁØæÑ àØÃM�lŒÄØ�ŒLãØÙk×ÄM×579;´ªÙ­Ù™
 ™
ÙkÔ ±ÙÔ
×�lŽd$²ÙüãÙIšÙ’ÚÙÚΠ èÙæÑ ƒÚòP�llëÙ�ŒL†ÚÙk*,.0üÕÚ$ùÖ´»ÚĺÚü±Ú#šÜÜÍì�l ÚÚÈlÝÅLÝü–Û8L™ÛÞhÈlÛ¥ÞÞÛ¸Û £ÛÇLÞh´¦ÛÞhÈL�lD³Û
Ý�lÞhù$¾Û;=ü¾Ü:ùÖ´¤ÜÄ£ÜüšÜ#¥à’ááàÈÕ ÃÜæÑ ÍÜåª,ÆÜ�ŒLÐÜþª,ÜܼeâãÙÚãâBDFH¼•Ý,˜Ýš
 š
¼e¼eß žÝß
âÔdŽd$ŸÝü†ß&T‰ß›
œ
 ›
¼e œ
¼eß ”ßß
ãÔdŽd$™ß¹
,ŸßüÇà=¥å’ææåÖÑ ÌàæÑ ×à�ŒLÚà�dç¢ç%')+´¡á4¤á�
 �
�d �
Ôdä «áä
çÔdŽd$¬áüÐá@¥é’êéêÖÑ ÕáæÑ àá�ŒLãá�dë¥ë%')+ü­â"T°âž
 ž
�d ž
Ôdè »âè
ëÔdŽd$Àâüèâ4¥í’îîíÖÑ íâæÑ øâ�ŒLûâ�dïâï%')+´¹ã4¼ãŸ
 Ÿ
�d Ÿ
Ôdì Ããì
ïÔdŽd$Äãüèã4¥ñ’òòñÖÑ íãæÑ øã�ŒLûã�dóåó%')+ô¹ä4¼ä 
  
�d  
Ôdð Ãäð
óÔdŽd$Èäü²íB¥õ’öõöÖÑ ·íæÑ Âí�ŒLÅ팑<íí�d#%')üùíY—ø’ùùøÎì‘n þíæÑ šî‚Ø‘n4Šî“í‘n,“î�ŒL�<ÊîÚmúûƒØ„ØûY[]_\Ùî4Þî÷÷‘nƒØü�ïM$�ï¡
¢
£
„¾„¾ñf†¾‰ ˜X$]È=„kt• ¡
Úm ¢
Ì�Ì�kÎ�wakerÁ¸�Ï� local_wakerÁ¸�Ð�extÁ¸�Ñ�·J¸�Ò�_marker2Á¸�f'EwÚ]¾å£
œØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÚmƒØ÷ £ï÷
û‘nŽd$™ïcxÁ¯ïüà•F»¤ŒÌ•ÌÆ•’ýýô¨ å•…©Lè•¡nþÒLþü­–B4°–¤
 ¤
¡n°rüšÿÿ Ü–üÍì°r ·–ÇL°rüº– °rÈL�f”Ç–
þºf°r$á–ù$ç–DFD”—þ<closure_kind>Á€<closure_signature>Á€<upvars>Á€€þ€ºf°r�f ¡n\ô»¤ŒàÌÚ<ø ¥ÖÞàáæÛÔo\ûØ�‚í$.ë�„ ManuallyDropÁd4ÃÛ�…½Ê\BÑÛ�†DropÁ$_Œ"�‡µ $u“�‰§<{‰�Šž,�‰f�‹‹¡‹��צ `�ŽèLÆ1�‘¾L4ÑÄ�’(¾LÅ�’( 4ÙèØ�“&ã4æ ¾�”ˆùh�•ï”¸ œ�–.ÁN„‚ç�™ÁNè�™ûLTÈé�™Ä½L"®(”—„‡|TtLifoX[\‰N$š@C14,±”±*-òôÝßTòÐüª ¤áÙn˜ü·)üü63 Details about the allocation that caused the errorÁ$¾¥
 ¥
Ùn»o— ×
˜$Äœèü� 2Ùn›ë›üÐ *$Ó »oÙnšš
›‚$Ø üœ
.»o�ë�ü® üÑ
B? Always evaluates to [`TryReserveErrorKind::CapacityOverflow`].Á$± Ãp»oœœ
� ü‡ %ÙnŸÅcŸü³ v ¦
§
¨
 ¦
Ùn §
 c cˆ¢cµ
 `£c€. `àB¤GS
¨
²¾ž à ž
Ÿ$Ä ×Ò tÄùÖ´ªÄ©ü #LÉ� ¡¢ø£¤’hÜ _L‚÷hÜ _L‚÷¡¢£¤¢¤l“�  ÅÏ�  ÅÏ4Ù�  ÅÏ�  ÅÏüž24°¥¦’§¦§ÈÕ ·æѬº�ŒL½‰qnýGâ@m¨©ªÝ469 º´b|××�¥¥âšTìì�¥¥Dü,ü�¥¥ŽdüäR¥¬’­­¬ÈÕ ðæÑ ó�ŒLöôÓ$¤ „Ô$± ‰q'),.ü—!R¥¯’°°¯ÈÕ £!æÑ ¦!�ŒL©!òÔ$×!�Õ$ä!‰q'),.Ìï!¥²²ÈÕ ô!à”³´µÔÕ$.\Å$â$à”±±Ø›üà)-ùÖ´œ)Ä›)ü’)#.\º)lç)à”±±
´Ôdþ Dõ)üÝ+4ùÖ´™+Ę+ü�+#.\·+¤ä+à”±±
µÔdþ Dù+üÕ,"¥·’¸¸·ÈÕ Ú,æÑ Ý,�ŒLà,‰q¹º»¼½¾¿ÀÁÂÃÄÈÉÊËÌJLOQü·/(„È/üß1%4ì1Žd‰q•�¤ÜLüí4:ùÖ´¹4ĸ4ü¯4#„ô4Žd‰q
»ÔdŽdþ D…5¤,–5ü¯7AùÖ´û6Äú6üñ6#¼¶7Žd‰q
¼ÔdŽdþ DÎ7¤,ß7ü¶=DDÄ=‰qÁ®
½ÔdŽd$Í=‘Ó=ü BBùÖ´ìAÄëAüâA#\£B�ÅÏŽd‰q
¾ÔdŽdþ D¯BinitÁ$ÀB¤,ÑBü¡QOŒ¯Qå‘Žd‰q
¿ÔdŽdµ ÁQþ DÎQ¤,ßQÜÙTàT©
 ©
‰qå‘ äT
ÀÔdŽd$åTü¦VD­Vª
 ª
‰q ¶V
ÁÔdŽd$·Vì¡XL¨X«
 «
‰q «
Žd ²X
ÂÔdŽd$³XüöX9tùX�¬
 ¬
‰qÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ„¶ݳ ˆY
ÃÔdŽd$‰Yü¬c8ùÖ´øbÄ÷büîb#<³c­
 ­
‰q »c
ÄÔdŽd$Àc‘Æc
additionalÁTÒcü‡g�¬Šg�®
 ®
‰q¥Æ’ÇÇÆ ÃgÈÕ  gæÑ £g�ŒL¦g
ÅÔdŽdslfÁ¾g‘âgêàTúg;=@Bü´k.ùÖ´€kÄÿjüöj#„»k¯
 ¯
‰q Ìk
ÈÔdŽd$Ñk‘×kü’m[\™m°
 °
‰qÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ùn ¥m
ÉÔdŽd$ªm‘°mêàT¼mü·u>ùÖ´ƒuÄ‚uüùt#l¾u±
 ±
‰q Ìu
ÊÔdŽd$Ñu‘×uêàTãuü·w€Œ¾w²
 ²
‰qíä Ùw
ËÔdŽd$Þw‘ìwêàT€xü°|+ùÖ´ü{Äû{üò{#l·|³
 ³
‰q Å|
ÌÔdŽd$Ê|ËÐ|ü‘}"¥Î’ÏÎÏÈÕ –}æÑ ™}�ŒLœ}‰qÐÑÒÓÔ&(+-ü÷~>lú~�´
 ´
‰qÍ ˆÍ
ÐÔdŽd$‰‘�êàT›ü�€=|“€�µ
 µ
‰që´Í £€Í
ÑÔdŽd$¨€µ ®€Ë€üœ‡ZtŸ‡�
 
‰qíäÍ ®‡Í
ÒÔdŽd$³‡‘¹‡êàTŇüª‘VT­‘�·
 ·
‰qíäÍ ¸‘Í
ÓÔdŽd$½‘‘ÑêàTÏ‘ü„—?ùִЖÄÏ–üÆ–#4‡—�¸
 ¸
‰qíäÍ Ž—Í
ÔÔdŽd$“—Ë™—”œÔÄÃÕÝÃÕûÃÕÕÔÕÔdŽd’c»o ݳüûŸÉ\þŸ�¹
Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ݳÃpöß ¹
ºfÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ë´Ùn’×× ù ô¨ Š …©Lº¡
ÖºføµT’ –!t¿ ¤,ò 24¹¢ÖÄÃØÝÃØûÃØØÖغfÃp»o�¦ÖÄÃÙÝÃÙûÃÙÙÖÙºf ïÙnªïü�§+¥Û’ÜÜÛÈÕ ”§æÑ —§�ŒLš§‰qÝ�"Ý%')+”­¨$°¨º
 º
‰qÚ µ¨Ú
ÝÔdŽd$º¨ü²ª6ùÖ´†ªÄ…ªüü©#tµª�íä
Þ� 4Ī„«ÞÄÃßÝÃßûÃßßÞßÙn»oüŠ°@\�°�íä
à
alloc_sizeÁT™°Üå³ùִ˳ÄʳüÁ³#Œè³�
á\œüJG A contiguous growable array type with heap-allocated contents, writtenÁlK
`Vec<T>`.ÁYúü]HE Vectors have *O*(1) indexing, amortized *O*(1) push (to the end) andÁô¦ *O*(1) pop (from the end).ÁÅúüÉDA Vectors ensure they never allocate more than `isize::MAX` bytes.ÁŽút’Ô¡úü¥:7 You can explicitly create a [`Vec`] with [`Vec::new`]:Áàú<侕üì! let v: Vec<i32> = Vec::new();Á<Ž¾•–úüš&# ...or by using the [`vec!`] macro:ÁÁú<ž•ìÍ let v: Vec<i32> = vec![];Áëúüï  let v = vec![1, 2, 3, 4, 5];Á�úü”&# let v = vec![0; 10]; // ten zeroesÁ<»¾•ÃúüÇPM You can [`push`] values onto the end of a vector (which will grow the vectorÁ|˜ as needed):Á¨ú<¬¾•Ü´ let mut v = vec![1, 2];ÁÐútÔ v.push(3);Á<㾕ëúüï.+ Popping values works in much the same way:Ážú<¢¾•ܪ�þÆú´Ê let two = v.pop();Á<ᾕéúüíRO Vectors also support indexing (through the [`Index`] and [`IndexMut`] traits):ÁÀú<ľ•ôÌ let mut v = vec![1, 2, 3];Á¬ë let three = v[2];Á¤� v[1] = v[1] + 5;Á<–¾•žú¼¢ [`push`]: Vec::pushÁ»¤ŒˆÌ‚¤ˆ«ýÑÖâÕÙÚþ�‹é‹âã®Dý¿ßâäí<š ðâå×­  `âæŽ$à šeâ莠eâè‘4É ¢eâéù$€
Œ5âê‹dº
ÃLâëâŸ\Ú
• âì⟖ âìí$÷
ëâîš<ý
 Àâï•Åd† ÃÛâð½Ê\” ÑÛâñ­
$²  âóBoundÁ,¸ ç£âôIndexÁ,¿ Ù¢âõIndexMutÁDÆ ³"âö RangeBoundsÁ\Ð ¤#â÷µ $î “âù§<ô ‰âúž$� ‰fâüÚT– “kâýèLã 1‾L4î Äâ�(¾LÅâ�(ã4û  ¾â‚ˆŽ
h⃥4¡
¥â…ÎM|©
Û↵O4ù
õ‡è(,È»ªà-Dõ�ü¿2dš×âáLãœòò´‹ ãL§ ÕT¶ Çʤ§Tú ™Ä®
‹ÌÌ
|Lë
Xñ
JM:=),L¦ ¬ 

õøÝàÃÆLâ ¸è ª­\‚ Ÿ,ˆ ‘”,Î ”Î Š�|RUT‡
GüÎ P;>,/¤ë
!T¦ùÖ´ŒÄ‹ü‚#4ªâõµ $ “ˆŠž$) ‰fˆŒèLL 1ˆŽ¾L4W Ĉ�(¾Lň�(è(,m »ˆ‘ªöt −L –
\ Š,! ¤5 ~€oq,e GI35ü±= 8»
š”’••”»
Éà  ÉÛ Ã ùM°rD¹ êÛLÆ Àr–—˜úMûMÿM—˜CEHJLõ $ú ““°rúMü¥( $¨ ¼
 ¼
ÀrÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÀrúM“ ­ “
—8°räh$² ü‹- LŽ ½
 ½
ÀrË£“ ˜ “
˜8°räh$™ üãH 8¾
šš’›š›¾
Éà è ÉÛ õ Ì�Dë êÛLø Àrœ�Mœ*,/1üÈ- LË ¿
 ¿
Àr Õ ™
œ8°räh$Ú ü F 8À
šž’ŸÀ
ŸžÉà ¥ ÉÛ ² Ì�D¨ êÛLµ Àr!$&üë9 8Á
š¡’¢Á
¡¢Éà ð ÉÛ ý Ì�Dó êÛL€ Àr£�"£*,/1”¹ $¼ Â
 Â
Àr  Á  
£8°räh$Æ üð% üÂ- * Private helper methods for `Splice::drop`Á8Ã
¥¥’¦Ã
¥¦¸Û õ ÉÛ ø êÛLû ªs§©"$üçN $ñ ˆÄ
Å
 Ä
ªs Å
š¤š¨¨ � ¤Íìô– ö ùMô–”ù ô–úMÞhD‚
§8Þhähô–$’ ãOd˜ IKü±1 L» ˆÆ
 Æ
ªs¤ Å ¤
©8Þhäh$Ê êàTÐ ”»æLÐ,Ôâ»×
 `«¬ÞÉlòP«­í$>뫯š<D À«°•ÅdMÃÛ«±µ $l“«³§<r‰«´ž$Ž‰f«èL±1«¸¾L4¼Ä«¹(¾LÅ«¹(öÑ⫺LýÌíL2Þ8ÏѾÀL`°f¡£\€•,†¤šŠŒz|TÊRüÊ7ü×%" A draining iterator for `Vec<T>`.Áýúü�/, This `struct` is created by [`Vec::drain`].Áü±# See its documentation for more.ÁÕúlÙ
# ExampleÁçú<뾕ôó let mut v = vec![0, 1, 2];Áü’/, let iter: std::vec::Drain<_> = v.drain(..);Á<¾•,Õø¼¥½’¾¼½¾¸Û ßÉÛÔæÞhøâêÛLéähøõឧeŽtÄ­KKtƒLÇ¿ÀÁÂèÛac¼i æ´b¼äªTµâ»»ÔãDîâ»»ü­#$¸â»»ÄlÄlIterÁÇlµ ™lÈl
end_or_lenÁ™lÉl·J™lŒœjSžøÞhüÖ"áâ»»‰‰§‹‰ ïíe¼îËè¿*É�üý@8Ç
¥Ä’ÅÅÄÇ
¸Û ‚ÉÛ ‘¿cÞhT…êÛL”ªsÆÀcÆ1368üÄ8ÇÈ
É
Ê
 È
ªs É
 c cˆ¢cµ
 `£c€. `àB¤GS
Ê
²¾Ã ËÃ
Æ8Þhäh$̱ ÒüÍ)øȥɒÊÈÉÊ¸Û ÖÉÛ ÙêÛLÜŽtËÌÍÒ&(+-ôƒ üý<9 Returns the remaining items of this iterator as a slice.Á¾útÆÔÙú<ᾕüí&# let mut vec = vec!['a', 'b', 'c'];Áü˜ " let mut drain = vec.drain(..);Áü¿ 30 assert_eq!(drain.as_slice(), &['a', 'b', 'c']);Áü÷ " let _ = drain.next().unwrap();Áüž
.+ assert_eq!(drain.as_slice(), &['b', 'c']);Á<Ñ
¾•.\Ý
DŠ Ë
 Ë
Žt Ë
ÝhÇ “ Ç
ËøÞhäh$” ì« üÌ 4ω.\… L² Ì
 Ì
Žt Ì
ähÇ ¼ Ç
ÌøÞhäh$½ ´–ü‡
0- Keep unyielded elements in the source `Vec`.Á¼
útÄ
Ô×
ú<ß
¾•üë
 #![feature(drain_keep_rest)]Á�úü˜&�¥üÃ"Í¥êúüò+( assert_eq!(drain.next().unwrap(), 'a');Á¢úüª.+ // This call keeps 'b' and 'c' in the vec.Á´Ý drain.keep_rest();Áøúü€)& // If we wouldn't call `keep_rest()`,Áä® // `vec` would be empty.ÁüÏ  assert_eq!(vec, ['b', 'c']);Á<ô¾•L�ŽtÇÇ
ÍøÞhäh$§ü™!8øϥВÑÑÏÐ¸Û ¢!ÉÛ ¥!êÛL¨!ŽtÒâÒž!(*-/Äî!4ñ!Í
 Í
Žt Í
ÝhÎ ø!Î
ÒøÞhäh$ù!üª"B8Î
¥Ô’ÕÔÎ
Õ¸Û ¶"ÉÛ ¿"� Þh$¹"� äh$Â"êÛLÉ"ªs57:<üñ"B8Ï
¥×’ØÏ
Ø×¸Û ý"ÉÛ †#ÌìÞh$€#Ììäh$‰#êÛL�#ªs79<>ü¸#28Ð
¥Ú’ÛÐ
ÚÛ¸Û ½#ÉÛ À#êÛLÃ#ªsÜÝßúMûMÿMÝß469;Lñ#$ö#ÙÙÞhü›$$ž$Ñ
 Ñ
ªsÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÞhÙ £$Ù
Ý8Þhäh$¨$,ô$ÝÄÃÞÝÃÞûÃÞÞÝÞÞhäh ÞhÞhüÂ%-LÅ%Ò
 Ò
ªsË£Ù Ï%Ù
ß8Þhäh$Ð%ü™&=8Ó
¥á’âáâÓ
¸Û ž&ÉÛ ¡&êÛL¤&ªsã�Mã"$')üó&$Lö&Ô
 Ô
ªs±´à €'à
ã8Þhäh$…',Ö'ãÄÃäÝÃäûÃääãäÞhäh‚¶üŒ(.8Õ
¥æ’ççÕ
æ¸Û ‘(ÉÛ ”(êÛL—(ªsè�"è"$')”Ï($Ò(Ö
 Ö
ªså ×(å
è8Þhäh$Ü(¿RLÃ)«ø+ëøì¥í’îëíîìÍìçu Õ)Íìíu Ø)1íuLÛ)øø+¼æ)çuø+íuø+çuø·íuøÌ©u·p×Ø`Ùëêï ø+»»è(¿�)âÀŸ)âÁùâÂÁâÄ­KKtƒLÇøçuíu©uõ¿RI«í¼©uéé
êø+øçuíuÍ)Ñ)LOKN;>«ééí¼ü‰*>ø+ñøò¥ó’ôôòñóß» –*ï» ™*ÿ»Lœ*©uõ�"õŽ*’*.035”Ö*$Ù*×
 ×
©uð Þ*ð
õø+øçuíu$ã*üœ?;8Ø
¥÷’ø÷Ø
ø¸Û ¡?ÉÛ ¤?êÛL§?ªsüÜ?78Ù
¥ú’ûûÙ
ú¸Û á?ÉÛ ä?êÛLç?ªsÌä©l€L„â�×
 `ýþÞÉlòPýÿâŸ\@• ý€âŸ– ý€í$]ëý‚š<c Àýƒ•ÅdlÃÛý„µ $Œ“ý†§<’‰ý‡ž$®‰fý‰�L$É ¿ýŠèLÜ1ýŒ€¾L4çÄý��(¾LÅý��(¥4ï¥ýŽ…ö¨âý�LdÌUÌ2FLQ"WL€ú†ëí\ Þ,¦œºÓ,ÔÄÆ°²|~T¡küÐ-ü®+( An iterator that moves out of a vector.ÁÚúüÞMJ This `struct` is created by the `into_iter` method on [`Vec`](super::Vec)Áü¬-* (provided by the [`IntoIterator`] trait).ÁÚúlÞ�œìú<ð¾•Ôø let v = vec![0, 1, 2];Áü“41 let iter: std::vec::IntoIter<_> = v.into_iter();Á<Ⱦ•DÛ¥‘’’‘’ÈÕ äæѬç�ŒLêŽvš¿ÖN3“”•–—˜Æ:<? ç´bÔ„�â��âšü¤"<¯â��Ô ¬Ì×â��üü!,‡â��ÃÛÃÛ•ÅÅÛ»¬„µÜÀ,�%*ŽdÄ£®â��–¤ÄÁÌâ��–¤üÞ?¥š’›š›ÈÕ ãæÑ ò›˜Tæ�ŒLõŽvœÀcœ*,/1ü¤8§Ú
Û
Ü
 Ú
Žv Û
 c cˆ¢cµ
 `£c€. `àB¤GS
Ü
²¾™ «™
œÔdŽd$¬± ²ü« $¥ž’ŸŸžÈÕ ° æÑ ³ �ŒL¶ Žv ¡¢£#%(*ôÄ üÖ <¥¤—
útŸ
Ô²
ú<º
¾•üÆ
" let vec = vec!['a', 'b', 'c'];Áüí
(% let mut into_iter = vec.into_iter();Áüš 74 assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);ÁüÖ &# let _ = into_iter.next().unwrap();Áü� 2/ assert_eq!(into_iter.as_slice(), &['b', 'c']);Á<¸ ¾•DË Ý
 Ý
Žv Ý
óe� Ô �
 ÔdŽd$Õ üŠ*ü¯
DA Returns the remaining items of this iterator as a mutable slice.Áø
út€Ô“ú<›¾•ü§"ßÎüÎ(‹Ïüû7½Ïü·&# into_iter.as_mut_slice()[2] = 'z';Áüâ/, assert_eq!(into_iter.next().unwrap(), 'a');Áü–/, assert_eq!(into_iter.next().unwrap(), 'b');ÁüÊ/, assert_eq!(into_iter.next().unwrap(), 'z');Á<þ¾•d‘Þ
 Þ
Žv Þ
óe� ž�
¡ÔdŽd$£ìÂüó4ωLÉß
 ß
Žv ß
Žd� Ó�
¢ÔdŽd$Ôü�*„„ýà
 à
Žv óe� •�
£ÔdŽd$šüý3¥¥’¦¦¥ÈÕ ‚æÑ …�ŒLˆŽv§â§"$')Ä·4ºá
 á
Žv á
óe¤ Á¤
§ÔdŽd$ÂüóA¥©’ªª©ÈÕ ÿæÑ ˆôÓ$‚�ŒL‹„Ô$—Žv'),.ü¹A¥¬’­¬­ÈÕ ÅæÑ ÎòÔ$È�ŒLÑ�Õ$ÝŽv'),.üÿ1¥¯’°¯°ÈÕ „æÑ ‡�ŒLŠŽv±²³´úMûMÿM€N²³´?ADFL·$¼®®Ôdüá$äâ
 â
Žv¦ª® é®
²ÔdŽd$îüÕ-LØã
 ã
ŽvË£® â®
³ÔdŽd$㼃,†Žv®®
´ÔdŽd$Œü¹<¥’··ÈÕ ¾æÑ Á�ŒLÄŽv¸�M¸"$')ü’$L•ä
 ä
Žv¦ªµ Ÿµ
¸ÔdŽd$¤üó":¥º’»»ºÈÕ ø"æÑ û"�ŒLþ"Žvü²#6¥½’¾¾½ÈÕ ·#æÑ º#�ŒL½#Žvü‘$=ùÖ´÷#Äö#üí##¥À’ÁÁÀÈÕ –$æÑ  $åª,™$�ŒL£$þª,¯$ŽvÂÙÂ2479¼Õ$,Ø$å
 å
ŽvŽv¿ Þ$¿
ÂÔdŽd$ß$ü�&-¥Ä’ÅÄÅÈÕ ¢&æÑ ¥&�ŒL¨&ŽvÆ�"Æ"$')”Ñ&$Ô&æ
 æ
Žvà Ù&Ã
ÆÔdŽd$Þ&©SLõ&ýøɥʒËÉÊË¸Û ƒ'ÉÛ †'êÛL‰'áž´”'÷žÇÇÈâ+̈ý ?Ó�L ö!IøÞhäh?Ó�L ö!IÈÌ øŸ©•æЩSÒýîæ•æÇÇ
ÈøÞhähÿ&ÞàãåàâýÇÇîæü¶'28ç
¥Î’Ïç
ÏÎ¸Û »'ÉÛ ¾'êÛLÁ'ãwÐ�"Ð"$')”÷'$ú'è
 è
ãwÍ ÿ'Í
Ð8Þhäh$„(t�T”âo=
»ÑÒèL]
1ÑÓöt
âÑÔÄ(
;üG
-Tm
ìz
„‡
 ˜
Ê
 ž
Ý

 Ÿ
¬
,  
 ¡
ª
, ¢
8varsÁ$£
& §
8¯¨

«
, ®
8”¯
& ²
8´³
$ µ
, ·
8rhsÁ¸
& »
8´¼
, ¿
 À
Û

8$,Á
, Ç
8´È
& Ê
8´Ë
& Í
, Ï
8boundÁ,Ð
& Õ
8¼,Ö
- Ü
*ß
 â
È
8$ì
 ð
8¥ ñ
$ ò
8¦ ô
$ õ
, ÷
 ø
þ
, ù
8þé$ú

ÿ
 €
8²L‚
 ‹
, Œ
8Øê�
 �
8
’
, –
8”—
8$,£
8¥ µ
& 
8²L¸
 Á
8¦ Â
 Ã
$ Ä
, Ò
 Ó
ß
, Ô
8´Õ
& ×
, Ù
8Èë,Ú
- à
 ê
Â
+ ø
 ù
ˆ
8Ý4ú
 €
‡
8±4�
8 –
8�™
 ›
¯
 œ
8$�
$ ¡
8¹
,£
& ¨
 ª
, «
8Øê¬
(±
8º$´
 ¹
Ñ
8$»
 ¿
Â
!À
Ä
8¹
,Ç
 Ì
Ï
!Í
+ ß
 à
ï
8Ý4á
 ç
î
8±4è
8 ý
8Ø €
 ‚
–
 ƒ
8$„
$ ˆ
8¹
,Š
& �
 ‘
, ’
8Øê“
(˜
8º$›
  
¸
8$¢
 ¦
©
!§
«
8¹
,®
 ³

!´
œÅùÖ´«Īü¡#|Éâ×ü¬"d¾âøØØ×׿2Ù‘ÖÚã2Ö‚û_Ö
g;ø‚û_Ö
g;ÙÚàË”ÕÕÖ×× ø„íLíÖ××Ì‚øÜÜ™ôÝÞ‡ü¸-Æâ“õ™ôÛÛ
Ýø‘ÊüØ8læâé
 é
™ôÛ ôÛ
Þø$ù incrementÁLÿôÁ8ê
ê
­}à�"à”ü$ÿë
 ë
­}ß „ß
à8$‰üƒ#q7üÛ^(ü©NK A contiguous growable array type, written as `Vec<T>`, short for 'vector'.ÁøútüÔ‹ú<�¾•ì— let mut vec = Vec::new();Á„µ
vec.push(1);Á„Æ
vec.push(2);Á×úìÛ assert_eq!(vec.len(), 2);ÁÔù assert_eq!(vec[0], 1);Á”úü˜# assert_eq!(vec.pop(), Some(2));Áì¼ assert_eq!(vec.len(), 1);ÁÚú|Þ vec[0] = 7;ÁÔî assert_eq!(vec[0], 7);Á‰úü�*' vec.extend([1, 2, 3].iter().copied());Á¸úœ¼ for x in &vec {ÁÄÐ println!("{x}");Á,éÆ™üï" assert_eq!(vec, [7, 1, 2, 3]);Á<’¾•šúüžA> The [`vec!`] macro is provided for convenient initialization:Áàú<侕üì! let mut vec1 = vec![1, 2, 3];ÁŒŽ vec1.push(4);Áü '$ let vec2 = Vec::from([1, 2, 3, 4]);ÁÜÈ assert_eq!(vec1, vec2);Á<侕ìúüðIF It can also initialize each element of a `Vec<T>` with a given value.ÁüºLI This may be more efficient than performing allocation and initializationÁü‡FC in separate steps, especially when initializing a vector of zeros:ÁÎú<Ò¾•ÌÚ let vec = vec![0; 5];Áüô%" assert_eq!(vec, [0, 0, 0, 0, 0]);Ášúüž;8 // The following is equivalent, but potentially slower:ÁüÚ(% let mut vec = Vec::with_capacity(5);Á¬ƒ vec.resize(5, 0);Áü™%¹�<¿¾•ÇúìË For more information, seeÁüé<9 [Capacity and Reallocation](#capacity-and-reallocation).Á¦úüª)& Use a `Vec<T>` as an efficient stack:ÁÔú<ؾ•üà let mut stack = Vec::new();Á€ú”„ stack.push(1);Á”— stack.push(2);Á”ª stack.push(3);Á½úüÁ'$ while let Some(top) = stack.pop() {ÁÌé // Prints 3, 2, 1ÁÔƒ println!("{top}");Á,žÆ™<¤¾•¬út° # IndexingÁ¿úüÃNK The `Vec` type allows to access values by index, because it implements theÁü’63 [`Index`] trait. An example will be more explicit:ÁÉú<;•ìÕ let v = vec![0, 2, 4, 6];Áüó0- println!("{}", v[1]); // it will display '2'Á<¤¾•¬úü°OL However be careful: if you try to access an index which isn't in the `Vec`,Áü€1. your software will panic! You cannot do this:Á²úœ¶ ```should_panicÁìÊõˆüè+( println!("{}", v[6]); // it will panic!Á<” ¾•œ úü  LI Use [`get`] and [`get_mut`] if you want to check whether the index is inÁtí  the `Vec`.Áü úl€!
# SlicingÁŽ!úü’!LI A `Vec` can be mutable. On the other hand, slices are read-only objects.Áüß!52 To get a [slice][prim@slice], use [`&`]. Example:Á•"ú<™"¾•ü¡"$! fn read_slice(slice: &[usize]) {ÁtÆ" // ...Á,Õ"Æ™Û"ú¼ß" let v = vec![0, 1];Áœ÷" read_slice(&v);Á‹#úÔ�# // ... and that's all!Áüª#$! // you can also do it like this:ÁÌÏ# let u: &[usize] = &v;Á¤é# // or like this:Á¬þ# let u: &[_] = &v;Á<”$¾•œ$úü $MJ In Rust, it's more common to pass slices as arguments rather than vectorsÁüî$OL when you just want to provide read access. The same goes for [`String`] andÁl¾%
[`&str`].ÁÌ%úüÐ% # Capacity and reallocationÁð%úüô%LI The capacity of a vector is the amount of space allocated for any futureÁüÁ&PM elements that will be added onto the vector. This is not to be confused withÁü’'KH the *length* of a vector, which specifies the number of actual elementsÁüÞ'NK within the vector. If a vector's length exceeds its capacity, its capacityÁü­(EB will automatically be increased, but its elements will have to beÁ„ó(
reallocated.Á„)úüˆ)PM For example, a vector with capacity 10 and length 0 would be an empty vectorÁüÙ)JG with space for 10 more elements. Pushing 10 or fewer elements onto theÁü¤*PM vector will not change its capacity or cause reallocation to occur. However,Áüõ*PM if the vector's length is increased to 11, it will have to reallocate, whichÁüÆ+QN can be slow. For this reason, it is recommended to use [`Vec::with_capacity`]Áü˜,GD whenever possible to specify how big the vector is expected to get.Áà,ú„ä,
# GuaranteesÁõ,úüù,MJ Due to its incredibly fundamental nature, `Vec` makes a lot of guaranteesÁüÇ-KH about its design. This ensures that it's as low-overhead as possible inÁü“.HE the general case, and can be correctly manipulated in primitive waysÁüÜ.PM by unsafe code. Note that these guarantees refer to an unqualified `Vec<T>`.Áü­/QN If additional type parameters are added (e.g., to support custom allocators),Áüÿ/63 overriding their defaults may change the behavior.Á¶0úüº0QN Most fundamentally, `Vec` is and always will be a (pointer, capacity, length)ÁüŒ1FC triplet. No more, no less. The order of these fields is completelyÁüÓ1LI unspecified, and you should use the appropriate methods to modify these.Áü 2KH The pointer will never be null, so this type is null-pointer-optimized.Áì2úüð2UR However, the pointer might not actually point to allocated memory. In particular,ÁüÆ3RO if you construct a `Vec` with capacity 0 via [`Vec::new`], [`vec![]`][`vec!`],Áü™4TQ [`Vec::with_capacity(0)`][`Vec::with_capacity`], or by calling [`shrink_to_fit`]Áüî4TQ on an empty Vec, it will not allocate memory. Similarly, if you store zero-sizedÁüÃ5VS types inside a `Vec`, it will not allocate space for them. *Note that in this caseÁüš6TQ the `Vec` might not report a [`capacity`] of 0*. `Vec` will allocate if and onlyÁüï6_\ if <code>[mem::size_of::\<T>]\() * [capacity]\() > 0</code>. In general, `Vec`'s allocationÁüÏ7NK details are very subtle --- if you intend to allocate memory using a `Vec`Áüž8RO and use it for something else (either to pass to unsafe code, or to build yourÁüñ8MJ own memory-backed collection), be sure to deallocate this memory by usingÁü¿9?< `from_raw_parts` to recover the `Vec` and then dropping it.Áÿ9úüƒ:RO If a `Vec` *has* allocated memory, then the memory it points to is on the heapÁüÖ:OL (as defined by the allocator Rust is configured to use by default), and itsÁü¦;MJ pointer points to [`len`] initialized, contiguous elements in order (whatÁüô;\Y you would see if you coerced it to a slice), followed by <code>[capacity] - [len]</code>ÁüÑ<1. logically uninitialized, contiguous elements.Áƒ=úü‡=KH A vector containing the elements `'a'` and `'b'` with capacity 4 can beÁüÓ=HE visualized as below. The top part is the `Vec` struct, it contains aÁüœ>KH pointer to the head of the allocation in the heap, length and capacity.Áüè>MJ The bottom part is the allocation on the heap, a contiguous memory block.Á¶?ú\º? ```textÁüÆ?&# ptr len capacityÁüí?'$ +--------+--------+--------+Áü•@'$ | 0x0123 | 2 | 4 |Áü½@'Ž±Œå@ |ÁŒ÷@ vÁü‰A0- Heap +--------+--------+--------+--------+ÁüºA0
function.Ášˆúü¢ˆ+ÖÐüÒˆ30 [`dealloc`]: crate::alloc::GlobalAlloc::deallocÁŠ‰út’‰Ô¥‰ú<­‰¾•Œ¹‰†üŒÏ‰ use std::mem;Áå‰úÔí‰ let v = vec![1, 2, 3];ÁŒŠúüÓŠEB // Prevent running `v`'s destructor so we are in complete controlÁÌ�‹ // of the allocation.Áü»‹*' let mut v = mem::ManuallyDrop::new(v);Áê‹úüò‹EB // Pull out the various important pieces of information about `v`ÁܼŒ let p = v.as_mut_ptr();Á´ÜŒ let len = v.len();ÁÜ÷Œ let cap = v.capacity();Á—�údŸ�©áü°�(% // Overwrite memory with 4, 5, 6ÁÌÝ� for i in 0..len {Áüû�(% ptr::write(p.add(i), 4 + i);ÁL¨Žý ¶Žúü¾Ž2/ // Put everything back together into a VecÁüõŽ74 let rebuilt = Vec::from_raw_parts(p, len, cap);Áü±�'$ assert_eq!(rebuilt, [4, 5, 6]);Á,Ý�Æ™<ç�¾•ó�úüû�.+ Using memory that was allocated elsewhere:Á®�ú\¶�×ÓôÆ�ˆéé�úüñ�<9 use std::alloc::{AllocError, Allocator, Global, Layout};Á²‘ú|º‘ fn main() {ÁüΑOL let layout = Layout::array::<u32>(16).expect("overflow cannot happen");Á¢’úÔª’ let vec = unsafe {ÁüÉ’52 let mem = match Global.allocate(layout) {Áüƒ“63 Ok(mem) => mem.cast::<u32>().as_ptr(),Áü¾“*' Err(AllocError) => return,Átí“ };Á€”úüˆ”! mem.write(1_000_000);Á®”úü¶”63 Vec::from_raw_parts_in(mem, 1, 16, Global)ÁTñ” };Á€•úüˆ•&# assert_eq!(vec, &[1_000_000]);Áü³•'$ assert_eq!(vec.capacity(), 16);Á,ß•Æ™<镾•t™–å‘ï€çç
ëÔdµ ¨–lengthÁ4µ–þ DÄ–ü²—¥í’îíîÈÕ ·—æÑ º—�ŒL½—ïïðñòóôõö÷øùúûüýþÿ€�‚ƒ…‡‰Œ¡¥³´µ·¸º»¼½¿ÁÃÄŘšœžü¥š%üØ—(% Constructs a new, empty `Vec<T, A>`.Á…˜úü�˜C©×Õ˜útݘÔð˜ú<ø˜¾•Ü„™°õ¤™úÔ¬™ # #[allow(unused_mut)]ÁüË™30 let mut vec: Vec<i32, _> = Vec::new_in(System);Á<ƒš¾•4²šŽdïìì
ïÔdŽd¤«Nüå«:ü¬›LI Constructs a new, empty `Vec<T, A>` with at least the specified capacityÁüý›  with the provided allocator.Á¢œúüªœH¯Úü÷œK�ÛüÇ�AÖÛ�žúü•žE­ÜüßžKüÜü¯ŸEÑÝüùŸ" Þ  úü¨ GØÞüô :©ß³¡úü»¡OL For `Vec<T, A>` where `T` is a zero-sized type, there will be no allocationÁü�¢1ÏàÅ¢úüÍ¢;–áü�£®Ò±£úd¹£ôáÊ£úüÒ£:–⑤út™¤Ô¬¤ú<´¤¾•ÜÀ¤°õà¤úüè¤41 let mut vec = Vec::with_capacity_in(10, System);Á¡¥úü©¥IËãì÷¥�äü™¦# assert_eq!(vec.capacity(), 10);ÁÁ¦úüɦ1üä¤ÿ¦¶å¤˜§Óå,±§Æ™ô»§ýåüÞ§#¤™†¨úüŽ¨1¿æŒÄ¨ùæôÚ¨“çüý¨"»ç¤©úü¬©Hóçôù©ÄèüœªDA let vec_units = Vec::<(), System>::with_capacity_in(10, System);Áüåª1§é<›«¾•ùÖ´±«Ä°«ü§«#„ì«Ždïìì
ðÔdŽdþ Dý«¤,Ž¬ü�Î^ü•­HE Creates a `Vec<T, A>` directly from a pointer, a capacity, a length,Á¬â­ and an allocator.Áü­úd„®çÑ•®úü�®FÌëdè®›ìù®úü�¯L½ìüÒ¯Q“íü¨°Rîíüÿ°6Êîüº±RŠïü‘²Pæïüæ²IÀðü´³<“ñüõ³PÙñüÊ
}Á�Ìúü•Ì!¢Œ»ÌúüÃÌ+( Vec::from_raw_parts(mem, 1, 16)ÁTóÌ›�‚ÍúüŠÍ&½�üµÍ'î�,áÍÆ™<ë;•Œ›Îå‘Ždïìì
ñÔdŽdµ ­ÎúŽ4ºÎþ DÉΤ,ÚÎüéÙ5ü—Ð2/ Decomposes a `Vec<T>` into its raw components.ÁÎÐúüÖÐA> Returns the raw pointer to the underlying data, the length ofÁüœÑ?< the vector (in elements), and the allocated capacity of theÁüàÑ@= data (in elements). These are the same arguments in the sameÁü¥Ò1. order as the arguments to [`from_raw_parts`].ÁÛÒúüãÒBîòüªÓ>; memory previously managed by the `Vec`. The only way to doÁüíÓA> this is to convert the raw pointer, length, and capacity backÁü³Ô?< into a `Vec` with the [`from_raw_parts`] function, allowingÁü÷Ô*' the destructor to perform the cleanup.Á¦Õúü®Õ+( [`from_raw_parts`]: Vec::from_raw_partsÁÞÕútæÕÔùÕú<�Ö¾•ü�Ö# #![feature(vec_into_raw_parts)]ÁüµÖ%" let v: Vec<i32> = vec![-1, 0, 1];ÁßÖúüçÖ-* let (ptr, len, cap) = v.into_raw_parts();Á™×úÔ¡× let rebuilt = unsafe {ÁüÀ×=: // We can now make changes to the components, such asÁü‚Ø<9 // transmuting the raw pointer to a compatible type.ÁüÃØ" let ptr = ptr as *mut u32;ÁêØúüòØ*' Vec::from_raw_parts(ptr, len, cap)Á4¡Ù‚Ûü¬Ù,) assert_eq!(rebuilt, [4294967295, 0, 1]);Á<ÝÙ¾•tðÙïå‘ìì
òÔdŽd$ÿÙüðæCü�Û2Ó¯ÄÛúüÌÛ[X Returns the raw pointer to the underlying data, the length of the vector (in elements),Áü¬Ü[X the allocated capacity of the data (in elements), and the allocator. These are the sameÁüŒÝJG arguments in the same order as the arguments to [`from_raw_parts_in`].ÁÛÝúüãÝBîòüªÞ>Ö²üíÞAŸ³ü³ßB? into a `Vec` with the [`from_raw_parts_in`] function, allowingÁüúß*µ´©àúü±à1. [`from_raw_parts_in`]: Vec::from_raw_parts_inÁçàútïàÔ‚áú<Šá¾•ü–á2/ #![feature(allocator_api, vec_into_raw_parts)]ÁÍáúÜÕá°õõáúüýá63 let mut v: Vec<i32, System> = Vec::new_in(System);Á|¸â v.push(-1);ÁtÌâ v.push(0);Átß⿧òâúüúâ?< let (ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();Á¾ãúÔÆã’·üåã=··ü§ä<ÿ·üèä"Ƹ�åúü—å41 Vec::from_raw_parts_in(ptr, len, cap, alloc)Á4Ðå‚ÛüÛå,ù<Œæ¾•Ì÷æïå‘Ždìì
óÔdŽd$‘çüØëü²éDA Returns the total number of elements the vector can hold withoutÁŒûé reallocating.Á‘êút™êÔ¬êú<´ê¾•üÀê30 let mut vec: Vec<i32> = Vec::with_capacity(10);ÁŒøê vec.push(42);ÁüŽë#¤™<¶ë¾•Dßëì
 ì
ïì èëì
ôÔdŽd$éëüÄñ,ü¡ìLI Reserves capacity for at least `additional` more elements to be insertedÁüòìC@ in the given `Vec<T>`. The collection may reserve more space toÁüºíHE speculatively avoid frequent reallocations. After calling `reserve`,Áü‡îHE capacity will be greater than or equal to `self.len() + additional`.ÁüÔî30 Does nothing if capacity is already sufficient.ÁŒïúd”ïôá¥ïúü­ï:–âìïútôïÔ‡ðú<�ð¾•Ô›ð let mut vec = vec![1];Á¤ºð vec.reserve(10);ÁüÓð"»ç<úð¾•ùÖ´�ñÄ�ñü†ñ#<Ëñí
 í
ïì Óñì
õÔdŽd$ØñêàTÞñü›ú2ü®òLI Reserves the minimum capacity for at least `additional` more elements toÁüÿòHE be inserted in the given `Vec<T>`. Unlike [`reserve`], this will notÁüÌóKH deliberately over-allocate to speculatively avoid frequent allocations.ÁüœôLI After calling `reserve_exact`, capacity will be greater than or equal toÁüíôFC `self.len() + additional`. Does nothing if the capacity is alreadyÁ|¸õ sufficient.ÁÌõúüÔõFC Note that the allocator may give the collection more space than itÁüŸöHE requests. Therefore, capacity can not be relied upon to be preciselyÁüìöB? minimal. Prefer [`reserve`] if future insertions are expected.Á³÷úì»÷÷ÓÝ÷údå÷ôáö÷úüþ÷:–â½øútÅøÔØøú<àø¾•ÔìøåÊÔ‹ù vec.reserve_exact(10);Áüªù"»ç<Ñù¾•ùÖ´çùÄæùüÝù#l¢úî
 î
ïì °úì
öÔdŽd$µúêàT»úü²…Oü‘ûTQ Tries to reserve capacity for at least `additional` more elements to be insertedÁüêûWT in the given `Vec<T>`. The collection may reserve more space to speculatively avoidÁüÆüIF frequent reallocations. After calling `try_reserve`, capacity will beÁü”ýDA greater than or equal to `self.len() + additional` if it returnsÁüÝýIF `Ok(())`. Does nothing if capacity is already sufficient. This methodÁü«þ30 preserves the contents even if an error occurs.ÁãþúdëþËÚüþúü„ÿPM If the capacity overflows, or the allocator reports a failure, then an errorÁ„Ùÿ
is returned.ÁîÿútöÿÔ‰€ú<‘€¾•ü�€52 use allocator_api2::collections::TryReserveError;Á×€úü߀HE fn process_data(data: &[u32]) -> Result<Vec<u32>, TryReserveError> {Áü¬�$! let mut output = Vec::new();ÁÕ�úüÝ�63 // Pre-reserve the memory, exiting if we can'tÁü˜‚(% output.try_reserve(data.len())?;ÁÅ‚úüÍ‚GD // Now we know this can't OOM in the middle of our complex workÁü™ƒ.+ output.extend(data.iter().map(|&val| {Áü̃+( val * 2 + 5 // very complicatedÁdüƒ }));Á�„ú”•„ Ok(output)Á,¬„Æ™ü¶„UR # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?");Á<�…¾•\¹…ï
 ï
ïíäì Å…ì
÷ÔdŽd$Ê…êàTÐ…üô’Uü†C@ Tries to reserve the minimum capacity for at least `additional`ÁüŠ‡JG elements to be inserted in the given `Vec<T>`. Unlike [`try_reserve`],ÁüÙ‡LI this will not deliberately over-allocate to speculatively avoid frequentÁüªˆLI allocations. After calling `try_reserve_exact`, capacity will be greaterÁüûˆFC than or equal to `self.len() + additional` if it returns `Ok(())`.ÁüƉ74 Does nothing if the capacity is already sufficient.Á‚ŠúüŠŠF˜ÐüÕŠHéÐü¢‹FC minimal. Prefer [`try_reserve`] if future insertions are expected.Áí‹úüõ‹%" [`try_reserve`]: Vec::try_reserveÁŸŒúd§ŒËÚ¸ŒúüÀŒPƒÙ„•�ÝÙª�út²�ÔÅ�ú<Í�¾•üÙ�5®Ú“Žúü›ŽHûÚüèŽ$ÎÛ‘�úü™�6ŠÜüÔ�.+ output.try_reserve_exact(data.len())?;Á‡�úü��G‹ÝüÛ�.ÝÝüŽ‘+–Þd¾‘ËÞÏ‘ú”בîÞ,î‘Æ™üø‘U™ß<Ò’¾•Œû’ð
 ð
ïíäì �“ì
øÔdŽd$’“êàT˜“ü©˜ü�”;8 Shrinks the capacity of the vector as much as possible.ÁДúüØ”JG It will drop down as close as possible to the length but the allocatorÁü§•LI may still inform the vector that there is space for a few more elements.Áø•út€–Ô“–ú<›–¾•ü§–)ŒãÔÕ– vec.extend([1, 2, 3]);Áüô–#¤™Äœ— vec.shrink_to_fit();Áü¹—! assert!(vec.capacity() >= 3);Á<ß—¾•ùÖ´õ—Äô—üë—#l°˜ñ
 ñ
ïì ¾˜ì
ùÔdŽd$ØüŠ 0ü˜›:7 Shrinks the capacity of the vector with a lower bound.Á×›úüß›A> The capacity will remain at least as large as both the lengthÁÜ¥œ and the supplied value.ÁÅœúüÍœJG If the current capacity is less than the lower limit, this is a no-op.Áœ�út¤�Ô·�ú<¿�¾•üË�)ŒãÔù�×ìü˜ž#¤™¬Àž vec.shrink_to(4);ÁüÚž! assert!(vec.capacity() >= 4);Á¬€Ÿ vec.shrink_to(0);ÁüšŸ!­í<ÀŸ¾•ùÖ´ÖŸÄÕŸüÌŸ#L‘ ò
 ò
ïì › ì
úÔdŽd$   min_capacityÁd¦ ü¬§0üÄ¡74 Converts the vector into [`Box<[T]>`][owned slice].Á€¢úüˆ¢EB If the vector has excess capacity, its items will be moved into aÁüÒ¢;8 newly-allocated buffer with exactly the right capacity.Á’£ú´š£ÒÔµ£út½£ÔУú<Ø£¾•Ô䣦�ƒ¤úü‹¤%" let slice = v.into_boxed_slice();Á<µ¤¾•Á¤úüɤ# Any excess capacity is removed:Áñ¤ú<ù¤¾•ü…¥)ŒãÔ³¥×ìÒ¥úüÚ¥#¤™ü‚¦'$ let slice = vec.into_boxed_slice();Áü®¦/, assert_eq!(slice.into_vec().capacity(), 3);Á<⦾•ùÖ´ø¦Ä÷¦üî¦#„³§ï¼eìì
ûÔdŽd$ȧü–³&üë©FC Shortens the vector, keeping the first `len` elements and droppingÁl¶ª
the rest.ÁȪúüЪEB If `len` is greater than the vector's current length, this has noÁ\š« effect.Áª«úü²«FC The [`drain`] method can emulate `truncate`, but causes the excessÁüý«/, elements to be returned instead of dropped.Á±¬úü¹¬A> Note that this method has no effect on the allocated capacityÁ”ÿ¬ of the vector.Á–­útž­Ô±­úü¹­52 Truncating a five element vector to two elements:Áó­ú<û­¾•ü‡®&# let mut vec = vec![1, 2, 3, 4, 5];Á¤²® vec.truncate(2);ÁäË® assert_eq!(vec, [1, 2]);Á<쮾•ø®úü€¯HE No truncation occurs when `len` is greater than the vector's currentÁ\ͯ length:Áݯú<対•üñ¯  let mut vec = vec![1, 2, 3];Á¤–° vec.truncate(8);Áü¯° assert_eq!(vec, [1, 2, 3]);Á<Ó°¾•ß°úüç°EB Truncating when `len == 0` is equivalent to calling the [`clear`]Á\±± method.ÁÁ±ú<ɱ¾•üÕ± ø€ ¤ú± vec.truncate(0);ÁÄ“² assert_eq!(vec, []);Á<°²¾•¼²úÌIJ [`clear`]: Vec::clearÁÌâ² [`drain`]: Vec::drainÁD�³ó
 ó
ïì ¦³ì
üÔdŽd$«³‘±³ô”½üàº2/ Extracts a slice containing the entire vector.Á—»úÜŸ» Equivalent to `&s[..]`.Á¿»útÇ»ÔÚ»ú<⻾•üî» use std::io::{self, Write};Áü’¼%" let buffer = vec![1, 2, 3, 5, 8];Áü¼¼1. io::sink().write(buffer.as_slice()).unwrap();Á<ò¼¾•D›½ô
 ô
ï ô
óeì ¤½ì
ýÔdŽd$¥½ü�À*üͽ2/ Extracts a mutable slice of the entire vector.Á„¾úüŒ¾ Equivalent to `&mut s[..]`.Á°¾út¸¾Ô˾ú<Ó¾¾•ôß¾ use std::io::{self, Read};Áü‚¿  let mut buffer = vec![0; 3];Áü§¿A> io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();Á<í¿¾•d–Àõ
 õ
ï õ
óeì £Àì
þÔdŽd$¨ÀüãÈ üÔÀKH Returns a raw pointer to the vector's buffer, or a dangling raw pointerÁü¤Á=: valid for zero sized reads if the vector didn't allocate.ÁæÁúüîÁDA The caller must ensure that the vector outlives the pointer thisÁü·ÂA> function returns, or else it will end up pointing to garbage.ÁüýÂ@= Modifying the vector may cause its buffer to be reallocated,ÁüÂÃ52 which would also make any pointers to it invalid.ÁüÃúü„ÄXU The caller must also ensure that the memory the pointer (non-transitively) points toÁüáÄYV is never written to (except inside an `UnsafeCell`) using this pointer or any pointerÁü¿ÅYV derived from it. If you need to mutate the contents of the slice, use [`as_mut_ptr`].Á�Æút¥ÆÔ¸Æú<Àƾ•ÔÌÆ let x = vec![1, 2, 4];ÁÜëÆ let x_ptr = x.as_ptr();Á‹Çúd“Ç©áì¤Ç for i in 0..x.len() {ÁüÆÇ.+ assert_eq!(*x_ptr.add(i), 1 << i);ÁLùÇý ,‡ÈÆ™<‘Ⱦ•�Èúü¥È# [`as_mut_ptr`]: Vec::as_mut_ptrÁ4êÈö
 ö
ï–¤ì ñÈì
ÿÔdŽd$òÈü½Ò&ü‰ËKH Returns an unsafe mutable pointer to the vector's buffer, or a danglingÁüÙËIF raw pointer valid for zero sized reads if the vector didn't allocate.Á§Ìúü¯ÌD¼� üøÌA‹Ž ü¾Í@׎ üƒÎ5¢� ½ÎútÅÎÔØÎú<àξ•üìÎ1. // Allocate vector big enough for 4 elements.ÁŒ¢Ï let size = 4;Áü¸Ï30 let mut x: Vec<i32> = Vec::with_capacity(size);ÁüðÏ let x_ptr = x.as_mut_ptr();Á”ÐúüœÐC@ // Initialize elements via raw pointer writes, then set length.ÁdäЩáÔõÐ for i in 0..size {Áü”Ñ%" *x_ptr.add(i) = i as i32;ÁL¾Ñý ÄÌÑ x.set_len(size);Á,éÑÆ™üóÑ# assert_eq!(&*x, &[0, 1, 2, 3]);Á<›Ò¾•TÄÒ÷
 ÷
ïå‘ì ÏÒì
€ÔdŽd$ÔÒì¼ÕüíÔ4ωLÃÕø
 ø
ï ø
Ždì ÍÕì
�ÔdŽd$ÎÕüÆí0ü„Ö1. Forces the length of the vector to `new_len`.ÁºÖúüÂÖC@ This is a low-level operation that maintains none of the normalÁüŠ×DA invariants of the type. Normally changing the length of a vectorÁüÓ×=: is done using one of the safe operations instead, such asÁü•Ø74 [`truncate`], [`resize`], [`extend`], or [`clear`].ÁÑØúüÙØ [`truncate`]: Vec::truncateÁÜýØ [`resize`]: Vec::resizeÁô�Ù [`extend`]: Extend::extendÁÌÀÙïƒ ÞÙúdæÙçÑ÷ÙúüÿÙ=: - `new_len` must be less than or equal to [`capacity()`].ÁüÁÚ=: - The elements at `old_len..new_len` must be initialized.ÁƒÛúü‹Û! [`capacity()`]: Vec::capacityÁ±Ûút¹ÛÔÌÛúüÔÛ@= This method can be useful for situations in which the vectorÁü™ÜA> is serving as a buffer for other code, particularly over FFI:ÁßÜúlçÜ
```no_runÁÔùÜ # #![allow(dead_code)]Áü˜Ý=: # // This is just a minimal skeleton for the doc example;ÁüÚÝ?< # // don't use this as a starting point for a real library.ÁüžÞ>; # pub struct StreamWrapper { strm: *mut std::ffi::c_void }ÁÔáÞ # const Z_OK: i32 = 0;Á”€ß # extern "C" {Áü—ß" # fn deflateGetDictionary(Áü¾ß*' # strm: *mut std::ffi::c_void,Áüíß" # dictionary: *mut u8,Áü”à%" # dictLength: *mut usize,Áœ¾à # ) -> i32;Á<Öà™�Ôâà # impl StreamWrapper {Áü�á52 pub fn get_dictionary(&self) -> Option<Vec<u8>> {Áü»áEB // Per the FFI method's docs, "32768 bytes is always enough".Áü…â2/ let mut dict = Vec::with_capacity(32_768);Áü¼â  let mut dict_length = 0;ÁüáâMJ // SAFETY: When `deflateGetDictionary` returns `Z_OK`, it holds that:Áü³ã63 // 1. `dict_length` elements were initialized.Áüîã41 // 2. `dict_length` <= the capacity (32_768)Áü§ä.+ // which makes `set_len` safe to call.Á„Úä
unsafe {Áüïä# // Make the FFI call...Áü—åYV let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length);ÁÔõå if r == Z_OK {Áü”æDA // ...and update the length to what was initialized.ÁüÝæ*' dict.set_len(dict_length);ÁÔŒç Some(dict)Á¤«ç } else {Á¤Äç NoneÁlÝ瘭Lïçý ,ýçÆ™<‡è™�<“辕Ÿèúü§èFC While the following example is sound, there is a memory leak sinceÁüòèA> the inner vectors were not freed prior to the `set_len` call:Á¸éú<À龕üÌé%" let mut vec = vec![vec![1, 0, 0],Áüöé%" vec![0, 1, 0],Áü ê&# vec![0, 0, 1]];ÁtËê // SAFETY:ÁüÞêFC // 1. `old_len..0` is empty so no elements need to be initialized.Áü©ë>; // 2. `0 <= capacity` always holds whatever `capacity` is.Ádìë©á¼ýë vec.set_len(0);Á,™ìÆ™<£ì¾•¯ìúü·ìEB Normally, here, one would use [`clear`] instead to correctly dropÁü�í*' the contents and thus not leak memory.Á<Ôíù
 ù
ïì Üíì
‚ÔdŽd$áínew_lenÁ<çíü¨ô0üÔî63 Removes an element from the vector and returns it.Á�ïúü—ïFC The removed element is replaced by the last element of the vector.Áâïúüêï30 This does not preserve ordering, but is *O*(1).Áü¢ðFC If you need to preserve the element order, use [`remove`] instead.ÁíðúÜõð [`remove`]: Vec::removeÁ•ñúd�ñôá®ñúü¶ñ'$ Panics if `index` is out of bounds.ÁâñútêñÔýñú<…ò¾•ü‘ò1. let mut v = vec!["foo", "bar", "baz", "qux"];ÁÇòúüÏò(% assert_eq!(v.swap_remove(1), "bar");Áüüò)& assert_eq!(v, ["foo", "qux", "baz"]);Áªóúü²ó(% assert_eq!(v.swap_remove(0), "foo");Áüßó" assert_eq!(v, ["baz", "qux"]);Á<†ô¾•\¯ôú
 ú
ïÔdì »ôì
ƒÔdŽd$ÀôÖ,ÆôüŒõ/l�õâ
„Ö,�õ‘«õüÏþ2ü‰ûJG Inserts an element at position `index` within the vector, shifting allÁüØû# elements after it to the right.Á€üúdˆüôá™üúä¡ü Panics if `index > len`.ÁÂüútÊüÔÝüú<åü¾•üñü ø€ ¬–ý vec.insert(1, 4);Áü°ý" assert_eq!(vec, [1, 4, 2, 3]);Á¬×ý vec.insert(4, 5);Áüñý%" assert_eq!(vec, [1, 4, 2, 3, 5]);Á<›þ¾•ùÖ´±þÄ°þü§þ#4Öþû
 û
ïÔdì Ýþì
…ÔdŽd$âþÖ,èþelementÁ<öþüµÿ/l¸ÿâ
†Ö,Æÿ‘Ôÿü¸�+üÀ‰JG Removes and returns the element at position `index` within the vector,Áü�Š/, shifting all elements after it to the left.ÁÊúüËŠC@ Note: Because this shifts over the remaining elements, it has aÁü“‹OL worst-case performance of *O*(*n*). If you don't need the order of elementsÁüç‹IF to be preserved, use [`swap_remove`] instead. If you'd like to removeÁüµŒ<9 elements from the beginning of the `Vec`, consider usingÁüöŒ$! [`VecDeque::pop_front`] instead.ÁŸ�úü§�%" [`swap_remove`]: Vec::swap_removeÁüÑ�JG [`VecDeque::pop_front`]: alloc_crate::collections::VecDeque::pop_frontÁ Žúd¨ŽôṎúüÁŽ'à» íŽútõŽÔˆ�ú<��¾•ôœ�„�ü¿� assert_eq!(v.remove(1), 2);ÁÔã� assert_eq!(v, [1, 3]);Á<‚�¾•²|Ž�4¿�€ü
 ü
ïÔdì Æ�ì
‡ÔdŽd$Ë�Ö,Ñ�ü¯‘/²|—‘l²‘�â
ˆÖ,À‘‘ΑüâžMüÞ—96 Retains only the elements specified by the predicate.Áœ˜úü¤˜NK In other words, remove all elements `e` for which `f(&e)` returns `false`.Áü÷˜LI This method operates in place, visiting each element exactly once in theÁüÈ™EB original order, and preserves the order of the retained elements.Á’šútššÔ­šú<µš¾•üÁš# let mut vec = vec![1, 2, 3, 4];Áüéš  vec.retain(|&x| x % 2 == 0);Á䎛 assert_eq!(vec, [2, 4]);Á<¯›¾•»›úüÛHE Because the elements are visited exactly once in the original order,Áü�œ@= external state may be used to decide which elements to keep.ÁÕœú<Ýœ¾•üéœ&åþü”�0- let keep = [false, true, true, false, true];ÁüÉ� let mut iter = keep.iter();Áüí�*' vec.retain(|_| *iter.next().unwrap());Áüœž assert_eq!(vec, [2, 3, 5]);Á<Àž¾•4éžþ
 þ
ï—ì—ŠŠ óžìÍìßÖ ðžý
“"ßÖ  ý
ÔdŒ�Ÿý
ßÖ ®× ˜"$ªŸ
‰ÔdŽdßÖ $øž± ‚Ÿeg4Ο‰ÄËÝËûË‹‰‹ÔdŽdßÖ  Ôd ßÖ üפUüêŸ\Y Retains only the elements specified by the predicate, passing a mutable reference to it.ÁË úüÓ RO In other words, remove all elements `e` such that `f(&mut e)` returns `false`.Áüª¡L«Ï üû¡E‚РŢútÍ¢Ôà¢ú<袾•üô¢#ˆÑ üœ£# vec.retain_mut(|x| if *x <= 3 {Á„Ä£
*x += 1;ÁdÙ£ trueÁdê£ } else {Álû£
falseÁ<�¤ });Áü™¤ assert_eq!(vec, [2, 3, 4]);Á<½¤¾•TÞ¤€  € ïßÖ ì—�� ì¤ìŒ× é¤ÿ
“"ßÖ  ÿ
Ôd¬–¥ÿ
ßÖ ‰Þ ˜"$§¥
ŒÔdŽdßÖ $ñ¤± û¤egüŬ+|̬âø�¥�’‘��‘¸Û à¬ÉÛ ã¬êÛLæ¬áž¤ÿ¬÷ž ŽŽ˜7’Áâ“Ï7â”ä7â•÷7âä¨ÓAoqá«øÞhähä¨ÓAoqá«’“”•™ܬª¬®°© ÿ¬âŽŽ‘‚¤¡­l¡­âŽŽ”í\í⎎œã­dã­âŽŽü‹®88� ¥—’˜˜—� ¸Û �®ÉÛ “®êÛL–®ó}™�"™%')+”Ò®$Õ®‚  ‚ ó}– Ú®–
™8Þhäh$ß®ü¡¶Öd¤¶â„ … †  „ ‘n … ŽŽ˜7’Áâ“Ï7â”ä7â•÷7âä¨ÓAoq᫆ Þhäh—›¥œ’�Ô8žœ›�ž ‹·Íì‘n ±¶¸Û ´¶ÉÛ ·¶Ô8œÅ¶êÛLº¶ƒ “"‘n ƒ Þh¬á·ƒ ‘nŒæ ˜"$ò·
š‘nÞhähÔ8÷7d綱 ˆ·² Ÿ·›�Ÿ¡£¥¢<˶,ºÂ$±ÃüÙÇoüÂÄ\Y Removes all but the first of consecutive elements in the vector that resolve to the sameÁD£Å key.Á°Åúü¸Å96 If the vector is sorted, this removes all duplicates.ÁöÅútþÅÔ‘Æú<™Æ¾•ü¥Æ+( let mut vec = vec![10, 20, 21, 30, 20];ÁÕÆúüÝÆ" vec.dedup_by_key(|i| *i / 10);Á„ÇúüŒÇ&# assert_eq!(vec, [10, 20, 30, 20]);Á<·Ç¾•dàLj  ˆ ïßÖ ì—¢œ£¢£ óÇìŒ× íÇÍìœ ðLJ “"ßÖ  ‡ Ôd”ŸÈ‡ ßÖ �ì ˜"óë °Èµßóë óë L¾È
¡ÔdŽdßÖ óë $øÇkeyÁ‚Șš‘“4åÈ¡ÄäÝäû䤡¤ÔdŽdßÖ óë òØ Ôd€Ù üñÎeü‰É_\ Removes all but the first of consecutive elements in the vector satisfying a given equalityÁlíÉ
relation.ÁÿÉúü‡ÊWT The `same_bucket` function is passed references to two elements from the vector andÁüãÊ[X must determine if the elements compare equal. The elements are passed in opposite orderÁüÃË\Y from their order in the slice, so if `same_bucket(a, b)` returns `true`, `a` is removed.Á¤Ìúü¬Ì9Îç êÌútòÌÔ…Íú<�;•ü™Í:7 let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];ÁØÍúüàÍ30 vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));Á˜Îúü Î2/ assert_eq!(vec, ["foo", "bar", "baz", "bar"]);Á<×ξ•Dø΋  ‹ ïßÖ ì—¦¦ „ÏìŒ× �ω Š “"ßÖ  ‰ Ôd Š Ôdì¸Ï‰ Š ßÖ Žõ ˜"$ÑÏ
¥ÔdŽdßÖ $‰Ï same_bucketÁ\“φˆüúÐ)l�Ñâø¨¥©’ª¨©ª¸Û “ÑÉÛ –ÑêÛL™Ñáž´ñÓ÷ž ×~€´¸ÌÔRR«¬­²�ÑMOQS\þÑ$þÑ⧧d‡Ó,‡Ó⧧†ñÓ⧧‘‚üœÔ:ø¯¥°’±°¯±¸Û ¥ÔÉÛ ¨ÔêÛL«Ô×~²�"²¡Ô,.02”åÔ$èÔŒ  Œ ×~® íÔ®
²øÞhäh$òÔüŽð ü¢í30 Appends an element to the back of a collection.ÁÚíúdâíôáóíúüûí:–âºîútÂîÔÕîú<Ýìéî let mut vec = vec![1, 2];Á„‹ï
vec.push(3);Áü ïÁ� <ÄﾕùÖ´ÚïÄÙïüÐï#$•ð�  � ïÔdì šðì
³ÔdŽd$Ÿð»,¥ðüÅýAüÌó\Y Appends an element if there is sufficient spare capacity, otherwise an error is returnedÁ¬­ô with the element.ÁÇôúüÏôWT Unlike [`push`] this method will not reallocate when there's insufficient capacity.Áü«õa^ The caller should use [`reserve`] or [`try_reserve`] to ensure that there is enough capacity.Á‘öú¼™öÿ�ìµö÷Óü×ö%àå�÷út‰÷Ôœ÷úü¤÷96 A manual, panic-free alternative to [`FromIterator`]:Áâ÷ú<ê÷¾•üö÷)& #![feature(vec_push_within_capacity)]Á¤øúü¬ø*' use std::collections::TryReserveError;ÁüÛø^[ fn from_iter_fallible<T>(iter: impl Iterator<Item=T>) -> Result<Vec<T>, TryReserveError> {Áü¾ù! let mut vec = Vec::new();ÁÜäù for value in iter {Áü„úA> if let Err(value) = vec.push_within_capacity(value) {ÁüÊú$! vec.try_reserve(1)?;Áüóúda // this cannot fail, the previous line either returned or added at least 1 free slotÁüÜû85 let _ = vec.push_within_capacity(value);Ál™ü˜­L«üý |¹ü Ok(vec)Á,ÍüÆ™ü×üGD assert_eq!(from_iter_fallible(0..100), Ok(Vec::from_iter(0..100)));Á<£ý¾•¤ÌýŽ  Ž ïÔdÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ôdì áýì
´ÔdŽd$æý»,ìýüóƒ"üŠ€LI Removes the last element from a vector and returns it, or [`None`] if itÁlÛ€
is empty.Áí€úüõ€:7 If you'd like to pop the first element, consider usingÁü´�$¥É Ý�úüå�J‘Ê ´‚út¼‚ÔÏ‚ú<ׂ¾•üã‚ ø€ üˆƒ# assert_eq!(vec.pop(), Some(3));Áä°ƒ³ÿ<у¾•úƒ�  � 寧ì þƒì
µÔdŽd$ƒ„ülj*üë…IF Moves all the elements of `other` into `self`, leaving `other` empty.Á¹†údÁ†ôáÒ†úüÚ†:–♇út¡‡Ô´‡ú<¼‡¾•üȇ ø€ üí‡! let mut vec2 = vec![4, 5, 6];ÁÔ“ˆ vec.append(&mut vec2);Áü²ˆ(% assert_eq!(vec, [1, 2, 3, 4, 5, 6]);ÁÌ߈ assert_eq!(vec2, []);Á<ýˆ¾•ùÖ´“‰Ä’‰ü‰‰#4Ή� ‘  � ï ‘ ïì Õ‰ì
ÔdŽd$Ú‰¹
,à‰üå‹7ùÖ´±‹Ä°‹ü§‹#|ï‹â’  ’ ï óeì ÿ‹ì
·ÔdŽd$„Œ¹
,ŠŒüç–`ü’ŽFC Removes the specified range from the vector in bulk, returning allÁüÝŽFC removed elements as an iterator. If the iterator is dropped beforeÁü¨�B? being fully consumed, it drops the remaining removed elements.Áï�úü÷�JG The returned iterator keeps a mutable borrow on the vector to optimizeÁ¼Æ� its implementation.Áâ�údê�ôáû�úüƒ‘DA Panics if the starting point is greater than the end point or ifÁüÌ‘;8 the end point is greater than the length of the vector.ÁŒ’úl”’
# LeakingÁ¦’úü®’LI If the returned iterator goes out of scope without being dropped (due toÁüÿ’FC [`mem::forget`], for example), the vector may have lost and leakedÁüÊ“?< elements arbitrarily, including elements outside the range.ÁŽ”út–”Ô©”ú<±”¾•ô½”„�üà”+( let u: Vec<_> = v.drain(1..).collect();ÁÄ�• assert_eq!(v, &[1]);ÁÜ­• assert_eq!(u, &[2, 3]);ÁÍ•úüÕ•:7 // A full range clears the vector, like `clear()` doesÁ„”–
v.drain(..);Á¼©– assert_eq!(v, &[]);Á<Å–¾•,î–“  “ »è(¿�)âÀŸ)âÁùâÂÁâÄ­KKtƒLÇ“ ÔdŽd죹¹ ÷–ìÍ캛
ô–¤#º›
”´—
¸ÔdŽdº›
$ü–rangeÁ,‚—>@¼¤¦üÙ£+( Clears the vector, removing all values.Á‰¤úü‘¤Aúü”פÅýî¤útö¤Ô‰¥ú<‘¥¾•ô�¥„�À¥útÈ¥ v.clear();ÁÛ¥úÔ㥠assert!(v.is_empty());Á<‚¦¾•,«¦”  ” ïì ±¦ì
ºÔdŽd$¶¦Ô®¬ü¾ªB? Returns the number of elements in the vector, also referred toÁ¤…« as its 'length'.Áž«út¦«Ô¹«ú<Á«¾•ÔÍ« let a = vec![1, 2, 3];ÁÜì« assert_eq!(a.len(), 3);Á<Œ¬¾•µ¬•  • ïì ¹¬ì
»ÔdŽd$º¬ôí®üç¬63 Returns `true` if the vector contains no elements.Á¢­útª­Ô½­ú<Å­¾•ÜÑ­ let mut v = Vec::new();ÁÔñ­‚ž
�®út˜®¿§Ü«® assert!(!v.is_empty());Á<Ë®¾•Dô®–  – ïì ý®ì
¼ÔdŽd$þ®üá´Jü±¯63 Splits the collection into two at the given index.Áì¯úüô¯IF Returns a newly allocated vector containing the elements in the rangeÁü°LI `[at, len)`. After the call, the original vector will be left containingÁü“±@= the elements `[0, at)` with its previous capacity unchanged.Áرúdà±ôáñ±úÌù± Panics if `at > len`.Á—²útŸ²Ô²²ú<º²¾•üƲ ø€ üë²  let vec2 = vec.split_off(1);ÁÌ�³ assert_eq!(vec, [1]);Á쮳 assert_eq!(vec2, [2, 3]);Á<г¾•ùÖ´æ³Äå³üܳ#.üš´B2use `.truncate()` if you don't need the other halfÁLè´—  — ïïì ò´ìþª,¥µ
½ÔdŽd$÷´atÁý´üãµ,læµâ
¾Ȫ
ôµ‘ÿµü³ÅYüÙ¼C@ Resizes the `Vec` in-place so that `len` is equal to `new_len`.Á¡½úü©½DA If `new_len` is greater than `len`, the `Vec` is extended by theÁüò½C@ difference, with each additional slot filled with the result ofÁüº¾C@ calling the closure `f`. The return values from `f` will end upÁü‚¿74 in the `Vec` in the order they have been generated.Á¾¿úüÆ¿C@ If `new_len` is less than `len`, the `Vec` is simply truncated.ÁŽÀúü–ÀEB This method uses a closure to create new values on every push. IfÁüàÀEB you'd rather [`Clone`] a given value, use [`Vec::resize`]. If youÁüªÁA> want to use the [`Default`] trait to generate values, you canÁüðÁ52 pass [`Default::default`] as the second argument.ÁªÂút²ÂÔÅÂú<;•üÙ ø€ üþÂ)& vec.resize_with(5, Default::default);Áü¬Ã%" assert_eq!(vec, [1, 2, 3, 0, 0]);ÁÖÃúÌÞà let mut vec = vec![];Á”üà let mut p = 1;Áü“Ä)& vec.resize_with(4, || { p *= 2; p });ÁüÁÄ# assert_eq!(vec, [2, 4, 8, 16]);Á<éľ•ùÖ´ÿÄÄþÄüõÄ#\ºÅ˜  ˜ ïßÖ ì—ÀÀ ÉÅìŒ× ÆÅ“"ßÖ dÿÅßÖ ˜"Ôd ŠÆ
¿ÔdŽdßÖ $ÎÅ«¸ <Ôű äÅY[üüÎ=üÙÇPM Consumes and leaks the `Vec`, returning a mutable reference to the contents,Áü®ÈJG `&'a mut [T]`. Note that the type `T` must outlive the chosen lifetimeÁüýÈK“�üÍÉ"é�ôÉúüüÉIF As of Rust 1.57, this method does not reallocate or shrink the `Vec`,ÁüÊÊIF so the leaked allocation may include unused capacity that is not partÁÔ˜Ë of the returned slice.Á·Ëúü¿ËK£Žü�ÌKùŽLßÌ leak.ÁíÌútõÌÔˆÍúŒ�Íí’¦Íú<®Í¾•ÔºÍ let x = vec![1, 2, 3];ÁüÙÍ41 let static_ref: &'static mut [usize] = x.leak();Á¼’Î static_ref[0] += 1;Áü®Î'$ assert_eq!(static_ref, &[2, 2, 3]);Á<Úξ•$ƒÏï øóeìøÂÂ줘¶Ï
ÁÔdŽdø$ŒÏˆÏü£×=ü¿ÐDA Returns the remaining spare capacity of the vector as a slice ofÁ¬ˆÑ `MaybeUninit<T>`.Á¢ÑúüªÑHE The returned slice can be used to fill the vector with data (e.g. byÁü÷ÑIF reading from a file) before marking the data as initialized using theÁ¼ÅÒ [`set_len`] method.ÁáÒúìéÒ [`set_len`]: Vec::set_lenÁ‹Óút“ÓÔ¦Óú<®Ó¾•üºÓ2/ // Allocate vector big enough for 10 elements.ÁüñÓ'$ let mut v = Vec::with_capacity(10);Á�Ôúü¥Ô$! // Fill in the first 3 elements.ÁüÎÔ(% let uninit = v.spare_capacity_mut();Á¼ûÔ uninit[0].write(0);Á¼—Õ uninit[1].write(1);Á¼³Õ uninit[2].write(2);ÁÏÕúü×ÕDA // Mark the first 3 elements of the vector as being initialized.Ád Ö©á¬±Ö v.set_len(3);Á,ËÖÆ™ÕÖúüÝÖ assert_eq!(&v, &[0, 1, 2]);Á<�×¾•”ª×™  ™ ï ™ ‰œì ½×ì
ÃÔdŽd$Â×ü÷èIüÑÚLI Returns vector content as a slice of `T`, along with the remaining spareÁü¢Û:7 capacity of the vector as a slice of `MaybeUninit<T>`.ÁáÛúüéÛNK The returned spare capacity slice can be used to fill the vector with dataÁü¼ÜNK (e.g. by reading from a file) before marking the data as initialized usingÁÜ�Ý the [`set_len`] method.Á¯Ýúì·ÝÓ¿
ÙÝúüáÝIF Note that this is a low-level API, which should be used with care forÁü¯Þ@= optimization purposes. If you need to append data to a `Vec`ÁüôÞ<9 you can use [`push`], [`extend`], [`extend_from_slice`],ÁüµßA> [`extend_from_within`], [`insert`], [`append`], [`resize`] orÁüûß30 [`resize_with`], depending on your exact needs.Á³àú¼»àÿ�Ü×à [`extend`]: Vec::extendÁü÷à1. [`extend_from_slice`]: Vec::extend_from_sliceÁü­á30 [`extend_from_within`]: Vec::extend_from_withinÁÜåáÓÓÜ…â [`append`]: Vec::appendÁÜ¥âõ  üÅâ%" [`resize_with`]: Vec::resize_withÁïâút÷âÔŠãú<’㾕üžã# #![feature(vec_split_at_spare)]ÁÆãúôÎã let mut v = vec![1, 1, 2];Áñãúüùã;8 // Reserve additional space big enough for 10 elements.Á”¹ä v.reserve(10);ÁÐäúüØä0- let (init, uninit) = v.split_at_spare_mut();Áü�å0- let sum = init.iter().copied().sum::<u32>();ÁÂåúüÊå# // Fill in the next 4 elements.ÁÌòå uninit[0].write(sum);Áì�æ uninit[1].write(sum * 2);Áì²æ uninit[2].write(sum * 3);ÁìÔæ uninit[3].write(sum * 4);Áöæúüþæ>; // Mark the 4 elements of the vector as being initialized.ÁdÁç©áÔÒç let len = v.len();ÁÜñç v.set_len(len + 4);Á,‘èÆ™›èúü£è-* assert_eq!(&v, &[1, 1, 2, 4, 8, 12, 16]);Á<Õ辕”þèš  š ï š óe š ‰œì ‘éì
ÄÔdŽd$–éü¾ìpÜÈìâ›  › ï › óe › ‰œ › ì íìì
ÅÔdŽd$òìüóó&¥Ç’ÈÇÈÈÕ øóæÑ ‚ôåª,ûó�ŒL…ôïÉÊË,.02üæû2ü ôC®«
èôúüðôD‰¬
ü¹õ>; difference, with each additional slot filled with `value`.ÁüüõCî
ÄöúüÌö41 This method requires `T` to implement [`Clone`],Áü…÷2/ in order to be able to clone the passed value.Áü¼÷KH If you need more flexibility (or want to rely on [`Default`] instead ofÁüŒø)& [`Clone`]), use [`Vec::resize_with`].ÁüºøHE If you only need to resize to a smaller size, use [`Vec::truncate`].Á‡ùút�ùÔ¢ùú<ªù¾•ü¶ù  let mut vec = vec!["hello"];ÁÜÛù vec.resize(3, "world");Áüûù1. assert_eq!(vec, ["hello", "world", "world"]);Á±úúü¹ú#ˆÑ ¬áú vec.resize(2, 0);Áäûú³ÿ<œû¾•ùÖ´²ûıûü¨û#4íûœ  œ ïÔdÆ ôûÆ
ÉÔdŽd$ùû«¸ <ÿû»,�üüÃ0üáý<9 Clones and appends all elements in a slice to the `Vec`.Á¢þúüªþJG Iterates over the slice `other`, clones each element, and then appendsÁüùþ>; it to this `Vec`. The `other` slice is traversed in-order.Á¼ÿúüÄÿC@ Note that this function is same as [`extend`] except that it isÁüŒ€B? specialized to work with slices instead. If and when Rust getsÁüÓ€EB specialization this function will likely be deprecated (but stillÁ|�� available).Á±�út¹�ÔÌ�ú<Ô�¾•Ôà�åÊüÿ�&# vec.extend_from_slice(&[2, 3, 4]);Áüª‚" assert_eq!(vec, [1, 2, 3, 4]);Á<Ñ‚¾•Ý‚úÜå‚êË
ùÖ´�ƒÄŽƒü…ƒ#ŒÊƒ� ž  � ï ž óeÆ ܃Æ
ÊÔdŽd$ჹ
,çƒüö‰Xü¬„>; Copies elements from `src` range to the end of the vector.Áï„úd÷„ôህúü�…Dƒ”
üÙ…;Ò”
™†út¡†Ô´†ú<¼†¾•üȆ&# let mut vec = vec![0, 1, 2, 3, 4];Áó†úüû†  vec.extend_from_within(2..);Áü ‡.+ assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4]);ÁÓ‡úüÛ‡  vec.extend_from_within(..2);Áü€ˆ41 assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4, 0, 1]);Á¹ˆúüÁˆ! vec.extend_from_within(4..8);Áüçˆ@= assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4, 0, 1, 4, 2, 3, 4]);Á<¬‰¾•ùִ‰ÄÁ‰ü¸‰#”ý‰Ÿ  Ÿ ﺛ
Æ£ÌÌ “ŠÆÅœ
�Šל
”»Š
ËÔdŽdº›
$˜ŠsrcÁžŠ13d”“ËÄÃÍÝÃÍûÃÍÍËÍÔdŽdº›
†¥ ±Ý Ôd¡•ËÄÃÎÝÃÎûÃÎÎËÎÔdŽdº›
Úí
  üº•4¥Ð’ÑŸÒÒÐÑÈÕ ¿•æÑ •‹êtЕ�ŒLÅ•ââöå€.âæ‘â¨ñ'N-y‚D‘kŽdÔcegik Ö•üÀ›(üõ•:7 Takes a `Vec<[T; N]>` and flattens it into a `Vec<T>`.Á´–úd¼–ôáÍ–úüÕ–JG Panics if the length of the resulting vector would overflow a `usize`.Á¤—úü¬—JG This is only possible when flattening a vector of arrays of zero-sizedÁüû—:7 types, and thus tends to be irrelevant in practice. IfÁüº˜0- `size_of::<T>() > 0`, this will never panic.Áï˜út÷˜ÔŠ™ú<’™¾•ôž™ #![feature(slice_flatten)]ÁÁ™úüÉ™85 let mut vec = vec![[1, 2, 3], [4, 5, 6], [7, 8, 9]];Áü†š+( assert_eq!(vec.pop(), Some([7, 8, 9]));Á¶šúü¾š-* let mut flattened = vec.into_flattened();Áüðš)& assert_eq!(flattened.pop(), Some(6));Á<ž›¾•tÇ›¾ï
ïÏÏ
ÔÔdŽdŸ$Ö›œë£Tñ£âÕ¥ÖÖÕü×üë£L¸Û ü£Õü×#ü×)×Ø×Ø×Ø46Ä…¤$ˆ¤â     „ØÞhÕ �¤Õ
ׄØÞh$’¤œ¢¤$¥¤â„ØÞhÕÕ
Ø„ØÞh$ª¤¥TlÀ¤â¥ÛÛÈÕ Τ°S™8ñÚÜÔd°¥TQâÔd°ÙÙ
ÚÔdgi ѤâÙÙÔdüÕ¤1¥ÞÞÈÕ Ú¤åª,ݤ°ßà×Øßà')¼£¥$¦¥â¡  ¡ °ÔdÝ «¥Ý
ßÔd$°¥”õ¥$ø¥â°ÔdÝÝ
àÔd$ý¥ü¢¦¥â’ãâãÈÕ §¦æÑ ª¦�ŒL­¦ïä!#üʧCùÖ´Ò¦ÄѦüȦ#\ͧ⢠ ¢ ï–á–åå ë§áÍì§þ
Ù§Õ§þ
Ôdlܧ
äÔdŽd§þ
$𧹠ö§»,„¨BDü¢¯*¥ç’èèçÈÕ §¯æÑ µ¯šµLª¯�ŒL¸¯ïé&(*,¼Ú²üÓ¯HE Removes consecutive repeated elements in the vector according to theÁü °'$ [`PartialEq`] trait implementation.ÁÌ°úüÔ°9Îç ’±útš±Ô­±ú<µ±¾•üÁ±&# let mut vec = vec![1, 2, 2, 3, 2];Áì±ú„ô±
vec.dedup();Á‰²úü‘²" assert_eq!(vec, [1, 2, 3, 2]);Á<¸²¾•,á²£  £ ïæ ç²æ
éÔdŽd$ì²4Š³éÄÃêÝÃêûÃêêéêÔdŽdüí üí´.¥ì’íìíÈÕ ò´æÑ õ´�ŒLø´ïîïê!ë!ï,.02\¢µ4§µëëóe¼Ðµ,Óµ¤  ¤ ï ¤ óeë Ùµë
ïÔdŽd$Úµüµ¶1¥ñ’òòñÈÕ º¶æÑ ½¶�ŒLÀ¶ïó÷!ó%')+üƒ·#L†·¥  ¥ ï ¥ óeð �·ð
óÔdŽd$•·ü ¸8ùÖ´†¸Ä…¸üü·#¥õ’ööõÈÕ ¥¸æÑ ¯¸åª,¨¸�ŒL²¸þª,¾¸ï÷øÙÚ÷øBDFH¼õ¸,ø¸¦  ¦ ïïô þ¸ô
÷ÔdŽd$ÿ¸üϺ&TÒº§ ¨  § ï ¨ ïô ݺô
øÔdŽd$⺹
,èºü¹Á.ü�¾HE The hash of a vector is the same as that of the corresponding slice,ÁüÖ¾=: as required by the `core::borrow::Borrow` implementation.Á”¿ú<˜¿¾•ü ¿-* #![feature(build_hasher_simple_hash_one)]Áüο use std::hash::BuildHasher;Áî¿úüò¿;8 let b = std::collections::hash_map::RandomState::new();Áü®À,) let v: Vec<u8> = vec![0xa8, 0x3c, 0x09];ÁüÛÀ'$ let s: &[u8] = &[0xa8, 0x3c, 0x09];ÁüƒÁ-* assert_eq!(b.hash_one(v), b.hash_one(s));Á<±Á¾•¥ú’ûúûÈÕ ¾ÁæÑ ÇÁÁÂ$ÁÁ�ŒLÊÁïü›eü.024ü„Â($‡Â© ª  © ï ª ÄÃù™ýý —Âùòà ŒÂ„Ä4�Â
üÔdŽdÄÃ$˜Âº,žÂ.0üÛÂ@¥ÿš€’��ÿ€ÈÕ àÂÉà ãÂÉÛ ÷“k°róe|æÂêÛLúÂ�{‚ƒÛ¢Ü¢ƒJLNPRT\¢Ã4§Ãþþ°róe•küÖÃ*,ÙÀ«  « �{°r « �{°rÛ¢þ ßÃþ
ƒÔd°räh$àÃÖ,æÃü±ÄC¥…š†’‡…†‡ÈÕ ¶ÄÉà ¹ÄÉÛ ÍÄÇ’ |¼ÄêÛLÐÄ�{ˆµ"ˆ79;=?Aü‘Å6L”Å€¬  ¬ �{°r ¬ †” „ žÅ„
ˆÔd°räh$£ÅÖ,©Åü§Æ"ùÖ´�ÆÄŒÆüƒÆ#¥ŠŠÈÕ ¬ÆÅL‹üæÆ:LéÆ°ršŒŒ‰Éà óÆÚôöÆ°rÈLÔdDƒÇ
‹Ôd°rù$ŽÇ46üôÇ0¥Ž’�Ž�ÈÕ ùÇæÑ üÇ�ŒLÿÇï�‘’ÈLÉLÊL’3579L«È$°È��Ôdl¾ÈDÃÈ��ŽvüªÍ$üãÈKH Creates a consuming iterator, that is, one that moves each value out ofÁü³ÉKH the vector (from start to end). The vector cannot be used after callingÁLƒÊ this.Á‘Êút™ÊÔ¬Êú<´Ê¾•üÀÊ30 let v = vec!["a".to_string(), "b".to_string()];ÁüøÊ# let mut v_iter = v.into_iter();Á Ëúü¨Ë63 let first_element: Option<String> = v_iter.next();ÁãËúüëË52 assert_eq!(first_element, Some("a".to_string()));Áü¥Ì52 assert_eq!(v_iter.next(), Some("b".to_string()));ÁüßÌ$! assert_eq!(v_iter.next(), None);Á<ˆÍ¾•L­ÍïïÉL��
’ÔdŽd$·ÍüßÒ8ø”¥•’–•–”¸Û èÒÉÛ ëÒêÛLîÒÃ�—˜™ÈLÉLÊL™äÒ;=?ALžÓ$£Ó““´‚lµÓDºÓ““© üôÓ$L÷ÓÃ�Ã�ÉL““
™øÞhäh$�Ôü¸Ô<ø›¥œ’�œ›�¸Û ÁÔÉÛ ÄÔêÛLÇÔ‘‚žŸ ÈLÉLÊL ½Ô;=?ALûÔ$€Õšš øÞhl–ÕD›ÕššÜlÜlIterMutÁßlµ ™làlÌŸ™lál·J™lÚ½íDþïl%øÞhüÂÕ$LÅÕ‘‚‘‚ÉLšš
 øÞhäh$ÏÕü®Ö-ùÖ´”ÖÄ“ÖüŠÖ#¥¢’£¢£ÈÕ ³ÖæÑ ¶Ö�ŒL¹Öï¤ÒL¤%')+üøÖ84ûÖ­  ­ ïš¡š¥¥ �סÍì´¦ ‚×ÇL´¦ ´…×´¦ ÈLÔdD’×
¤ÔdŽd´¦ $¢×ù$¨×IKü£Þ¥§’¨¨§ÈÕ ¨ÞæÑ «Þ�ŒL®Þï©!#ü¥é£üÉÞOL Creates a splicing iterator that replaces the specified range in the vectorÁü�ßHE with the given `replace_with` iterator and yields the removed items.ÁüêßB? `replace_with` does not need to be the same length as `range`.Á±àúü¹àJG `range` is removed even if the iterator is not consumed until the end.Áˆáúü�áC
ü©æ;Ò”
éæútñæÔ„çú<Œç¾•ü˜ç! let mut v = vec![1, 2, 3, 4];Áľç let new = [7, 8, 9];ÁüÛç2/ let u: Vec<_> = v.splice(1..3, new).collect();Áü’è$! assert_eq!(v, &[1, 7, 8, 9, 4]);ÁÜ»èÖ˜
<Û辕ùÖ´ñèÄðèüçè#4¬é®  ® ﺛ
ô–õõµOù�(âúãOâÙml¶ð™‡ž® ô–ÉLŽd¦£ªš«ª« ¹é¦Åœ
³é — ¶éל
”’êÇLô–´±êô–ÈLÔdD¾ê
©ÔdŽdº›
ô–$¾éƒœ
,ÄéãOdÎéikmoü’îEüÍëb_ Extend implementation that copies elements out of references before pushing them onto the Vec.Á°ìúü´ì`] This implementation is specialized for slice iterators, where it uses [`copy_from_slice`] toÁü•í$! append the entire slice at once.Áºíúü¾í/, [`copy_from_slice`]: slice::copy_from_sliceÁùÖ´øíÄ÷íüîí#ø­¥®’¯¯®­¸Û ›îÉÛ ©îÚÛ$žîឥîêÛL¬î÷ž¸îÉ�°ÒL°—îHJ­OQ­üôî<4÷î¯  ¯ É�ô–¬š±± �ﬠ— þîд Ô�ïô–ÈL´‚dŽï
°øÞhähô–$¢ïù$¨ïHJü­õ:üÇôeb Implements comparison of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison).Á¥³’´´³ÈÕ ²õæÑ Áõœ¸Tµõ�ŒLÄõïµïßµ/135ü„ö7\‡ö° ±  ° ï ± ïÖ¹² “ö²
µÔdŽd$”ö¹
,šöüúö*¥·’¸¸·ÈÕ ÿöæÑ †÷ËÁ‚÷�ŒL‰÷ï#%')ü�ø,ü©÷c` Implements ordering of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison).Á¥º’»º»ÈÕ ’øæÑ šøп•ø�ŒL�øï¼»¼.024üÖø'Ùø² ³  ² ï ³ ¹ Ýø¹
¼ÔdŽd$Þø¹
,äøü­ù(¥¾’¿¾¿ÈÕ ²ùæÑ µù�ŒL¸ùïÀ�"À%')+”òù$õù´  ´ ï½ úù½
ÀÔdŽd$ÿùÔðü¥ÂÂÈÕ õüï€Ã´Ã´šþô‘ý Creates an empty `Vec<T>`.Á´ýúü¼ýC©×<�þï€ÁÁ
ÃÔdüÏþ:¥Å’ÆÆÅÈÕ ÔþæÑ ãþ›˜T×þ�ŒLæþïÇÀcÇ.024ü¦ÿ8©ÿµ  ·  µ ï   c cˆ¢cµ
 `£c€. `àB¤GS
· ²¾Ä ­ÿÄ
ÇÔdŽd$®ÿ± ´ÿüŽ€4¥É’ÊÉÊÈÕ “€æÑ –€�ŒL™€ïËâË%')+ô߀4‸  ¸ ï«È È é€È
ËÔdŽd$ê€ü–�4¥Í’ÎÍÎÈÕ ›�æÑ ž��ŒL¡�ïÏåÏ%')+üç�&4ê�¹  ¹ ïüÉ Ì ñ�Ì
ÏÔdŽd$ö�ü¦‚.¥Ñ’ÒÑÒÈÕ «‚æÑ ®‚�ŒL±‚ïÓâÓ%')+Äñ‚4ô‚º  º ï º óeÐ û‚Ð
ÓÔdŽd$ü‚ü¢ƒ.¥Õ’ÖÕÖÈÕ §ƒæÑ ªƒ�ŒL­ƒï×å×%')+üíƒ 4ðƒ»  » ï » óeÔ ÷ƒÔ
×ÔdŽd$üƒüÊ„$ùÖ´°„į„ü¦„#8¼ ¥ÙÙ¼ ¸Û Ï„ØÞh,Ò„ºƒÚëÚ$&ÔĆüõ„;8 Allocate a `Vec<T>` and fill it by cloning `s`'s items.Áµ…út½…ÔÐ…ú<Ø…¾•üä…96 assert_eq!(Vec::from(&[1, 2, 3][..]), vec![1, 2, 3]);Á<¢†¾•$dž½  ½ ÝhºƒØ φØ
Ú8Þh¾ ̆üï‡(ùÖ´Õ‡ÄÔ‡üˇ#8¾ ¥Ü¾ Ü¸Û ô‡¶Î ,÷‡ºƒÝëÝôñ‰üžˆ;òÍ ÞˆútæˆÔùˆú<�‰¾•ü�‰=: assert_eq!(Vec::from(&mut [1, 2, 3][..]), vec![1, 2, 3]);Á<ω¾•$ô‰¿  ¿ ÝhºƒÛ ü‰Û
Ý8Þh¾ ù‰ü ‹/ùÖ´†‹Ä…‹üüŠ#¥ßŸààßÈÕ ¥‹Íìt¨‹ï€âëâ! ®‹äì‹$ï‹Êjï€ÞÞ
âÔdŸ¾ ô‹ü¿Œ5¥å’æåæÈÕ ÄŒæÑ ÇŒ�ŒLÊŒïçëç%')+üª�üûŒDA Convert a boxed slice into a vector by transferring ownership ofÁüÄ�! the existing heap allocation.Áê�útò�Ô…Žú<�Ž¾•ü™Ž96 let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();Áü׎,) assert_eq!(Vec::from(b), vec![1, 2, 3]);Á<ˆ�¾•$­�¼eïää
çÔdŽd¾ ²�üê�H¥é’êŸëëéêÈÕ ï�æÑ ò�‹êt€��ŒLõ�ïíëí.0246 †�üÞ’"ü¹�DA Convert a boxed array into a vector by transferring ownership ofÁü‚‘! Ö ¨‘út°‘ÔÑú<Ë‘¾•üב/, let b: Box<[i32; 3]> = Box::new([1, 2, 3]);Áü‹’,Æ× <¼’¾•$á’Újïèè
íÔdŽdŸ¾ æ’üý“5ùÖ´ã“Äâ“üÙ“#¥ð’ñðñÈÕ ‚”æÑ …”�ŒLˆ”¼eòëò%')+ìõ˜ü¹”(% Convert a vector into a boxed slice.Áæ”úüî”>; If `v` has excess capacity, its items will be moved into aÁü±•;�õñ•útù•ÔŒ–ú<”–¾•ü –KH assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());Á<𖾕ü–úü„—#š÷<¬—¾•ü¸—)ŒãÔæ—×ì…˜úü�˜A> assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice());Á<Ó˜¾•$ø˜ï¼eïï
òÔdŽdÁ ý˜Üß™ùÖ´Å™ÄÄ™ü»™#8À À Ç„ôëôÜΛü�š96 Allocate a `Vec<u8>` and fill it with a UTF-8 string.Á¿šútÇšÔÚšú<âš¾•üîš96 assert_eq!(Vec::from("123"), vec![b'1', b'2', b'3']);Á<¬›¾•$Ñ›Á  Á Ç„ó Ù›ó
ô8¾ Ö›ü–œC¥ö’÷Ÿø÷öøÈÕ ›œæÑ žœ‹êt¬œ�ŒL¡œ‘kúûòóû5
v.sort();Á”‚£ v.truncate(2);Áü™£/, let [a, b]: [_; 2] = v.try_into().unwrap();ÁÄÍ£ assert_eq!(a, b' ');ÁÄê£ assert_eq!(b, b'd');Á<‡¤¾•D¬¤ïÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
‘kïõõ
ûÔdŽdŸÁ¹¤üÝ©UùÖ´´©ij©üª©#4Ô©dä©ÔdŽdï¥ÿ’€€ÿÈÕ ñ©æÑ û©åª,ô©�ŒLþ©
þÔdŽdelemÁ$‰ª¹ ’ª¤,œªJLNPüß«7ùÖ´¶«ĵ«ü¬«#4Ö«Læ«Ôd‚‚ÈÕ ð«åª,ó«
�ÔdÐð $ú«¹ ƒ¬)+TÄ»¤Œ°̪4È„ú ü/ , Creates a [`Vec`] containing the arguments.Á0 úü4Q N `vec!` allows `Vec`s to be defined with the same syntax as array expressions.Áü†& # There are two forms of this macro:Á­ úü±; 8 - Create a [`Vec`] containing a given list of elements:Áí ú<ñ ¾•äù  use allocator_api2::vec;ÁÔ– ¦�ı  assert_eq!(v[0], 1);ÁÄÊ  assert_eq!(v[1], 2);ÁÄã  assert_eq!(v[2], 3);Á<ü ¾•„ úˆ ú<Œ ¾•ü”- * use allocator_api2::{vec, alloc::Global};ÁüÂ% " let v = vec![in Global; 1, 2, 3];ÁÄè Ðõ Ä� ñõ Äš ’ö <³ ¾•» úü¿5 2 - Create a [`Vec`] from a given element and size:Áõ ú<ù ¾•ä� žõ ¼ž  let v = vec![1; 3];Áì¶  assert_eq!(v, [1, 1, 1]);Á<Ô ¾•Ü ú<à ¾•üè- æö ü–"  let v = vec![in Global; 1; 3];Áì¹ �ù <× ¾•ß úüãH E Note that unlike array expressions this syntax supports all elementsÁü¬K H which implement [`Clone`] and the number of elements doesn't have to beÁ|ø a constant.Áˆ úüŒN K This will use `clone` to duplicate an expression, so one should be carefulÁüÛJ G using this with types having a nonstandard `Clone` implementation. ForÁü¦ J G example, `vec![Rc::new(1); 5]` will create a vector of five referencesÁüñ R O to the same boxed integer value, not five references pointing to independentlyÁœÄ
 boxed integers.ÁØ
úüÜ
M J Also, note that `vec![expr; 0]` is allowed, and produces an empty vector.Áüª Z W This will still evaluate `expr`, however, and immediately drop the resulting value, soÁü…   be mindful of side effects.Á¥ úä©  [`Vec`]: crate::vec::VecÁùÖ´Ð ÄÏ üÆ # (|ê U ‹
î  ‘
¦
8’
, •
8¤,–
& ›
8›$œ
, ¡
 ¢
¤
% £
- ¥
*¨
 «
Ú
 , µ
8,¶
'»
8Á½
'À
8öÂ
'Å
8Û 4Ç
 Í
Ô
, Î
8¤,Ï
% Û
 á
… 8â
, å
8¤,æ
& ë
8›$ì
% ð
, ò
8Ðð $ó
& ÷
8›$ø
% ü
, þ
8¹ ÿ
& € 8›$� *‡  Š Å , ” 8,• 'š 8Áœ 'Ÿ 8ÑGd¡  ­ ¿ , ® 8Ðð $¯ $ ³ , µ 8¹  $ · , ¹ 8¤,º % Æ  Ì ï 
8Í , Ð 8¤,Ñ & Ö 8›$× % Û , Ý  Þ æ , ß 8Ã à & á 8›$â $ ç  è , ê  ë í $ ì - î *ñ  ô ¤ 
, þ 8,ÿ '„ 8ä,† '‹ 8ˆ� '�  ’  “ • 8 ”  – '— 8ˆ
D™  ¡ ž , ¯ 8,° 'µ 8ä,· '¼ 8ˆ¾ 'Á 8ž,à  È ” , Ú 8,Û 'à 8ä,â 'ç 8ˆé 'ì 8Û 4î  ô †  õ ý , ö  ÷ ú , ø 8à ù $ û  ü $ þ , € 8¤,� % ¥  « ¬ *®  ± ×  , » 8,¼ 'Á 8Áà 'Æ 8öÈ 'Ë 8æ Í  Ð Ñ % Ø  Þ ò  , ß 8Ðð $à & ä 8›$å % é , ë 8¹ ì & í 8›$î *ô  ÷ § , � 8,‚ '‡ 8Á‰ 'Œ 8õGLŽ  — ¡ , ˜ 8Ðð $™ $ � , Ÿ 8¹   % ¨  ® Á , ¯  ° ¸ , ± 8à ² & ³ 8›$´ $ ¹  º , ¼  ½ ¿ $ ¾ - À *à  Æ ë 
, Ð 8,Ñ 'Ö 8ä,Ø 'Ý 8ˆß 'â  ä  å ç 8 æ  è 'é 8ˆ
Dë  ó å , � 8,‚ '‡ 8ä,‰ 'Ž 8ˆ� '“ 8ž,•  š Û , ¬ 8,­ '² 8ä,´ '¹ 8ˆ» '¾ 8æ À  Ã Í  Ä Ì , Å  Æ É , Ç 8Ã È $ Ê  Ë % ì L뻤Œ×ÌÑ,ï‹èL
1…ˆ¾L4$
Ä…‰(¾LÅ…‰(ö6
â…Š,
”
Y[JLD1
"¬{
ü?;
8 Slice methods that use `Box` and `Vec` from this crate.ÁD…
‹¥ŒŒ‹ü×ü{Œ
¸Û Ž
‹ü×!ü×'�Ž��Ž���Ž<>ü®>
ü—#
Copies `self` into a new `Vec`.Á¿
útÇ
ÔÚ
ú<â
¾•Ìî
 let s = [10, 40, 30];Á¼Œ
Reference in New Issue Copy Permalink