Files
boc/aamos-ledger-rust/target/debug/deps/libtokio_stream-b264e64a1923550f.rmeta
T

2756 lines
653 KiB
Plaintext
Raw Normal View History

rust
Ü2
#rustc 1.96.0 (ac68faa20 2026-05-25)ÁÀ뉊]!ÜÛê(¹Þ—šên-5be7b69c3ff7b5b8ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁ¤²XctÔ'ÐÓ©z¨ɽÓ-a4945860e1c53b00Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁòÖÀH•‘PIÓHã#£-055f30b747f859b6Árustc_std_workspace_coreÁ­Cçß^ò½èÝ$­Çÿ+Cé-c4878ee60b2242c9ÁŸÃï+Ñ]ŠqB<ÏïW#-8dd1dd90e70d0b6aÁ miniz_oxideÁ€š»J(P>àö÷g\K-1eb618da2918ab7fÁadler2ÁÆ;+Þ®5¥Ìýݰ¦ÛLˆ-f7919172d268e069Á hashbrownÁPäV9ÒÆèÜ"ÊÖVŽ\-0fc2184a5da6723aÁrustc_std_workspace_allocÁs&ØòØy¯s•bæ!‰ýŠ-97e4bf30be240674Á
std_detectÁhŠBîÙºÌI®ËÅš-9dbbf8346ba7ac8bÁrustc_demangleÁûë9´Ç×@Œ’ùXFº-f33013f239bf9f14Ácfg_ifÁÜLhž§Œaã¯>­-0a71c8f33a838301Á addr2lineÁ׎Þ!]8V$É@@-e618e6be60e87ba2ÁgimliÁ¸
°µ~Î1‹Ñt ðÁ€w-1f7768a68858f670ÁobjectÁ
áPÃ?­À¶¼QHJ¥-914cd6a4dbe590d1ÁmemchrÁ›º«8Ór­2Ù $¨ûib-cf21ca6f2bb15dcdÁë
‹ás«LÖ€îâƒ×ɯŒ-ee6f3747e38367f0ÁtokioÁ,¿¢¨˜É0!ñ?-…”¼9-3beca82a6f76b5d4Ápin_project_liteÁ·x¼+Ä`·á¨›t—¸Íœ-2dc344ecc91b59efÁmioÁGùj0ðÔ·â"FÆ#0Q-3545320490828222Áæ\‹±ÔcdùÀTƒ-f86f80b348d33b13ÁbytesÁ`²['3_²µÆ=üå¥-d4f44708ed5da7b6Ásocket2ÁsT›¸n>~RÊ1G/R-c161f09f0083d1e0Á futures_coreÁÆöc$޳–º¾v¸dK-ac1e9cdb826f83c0ÁrandÁ$¯³loomÁ$‘³ BroadcastStreamRecvErrorÁĦ»çß
broadcastÁLÜ»çß
BroadcastStreamÁ|þ»ç&(
watchÁ,˜»ç?A
WatchStreamÁ\²»ç^`
signal_unixÁ\ù»signalÁ¥
SignalStreamÁdÀ»ó #%
signal_windowsÁtø»ó EG
CtrlCStreamÁ\Æ»ó df
CtrlBreakStreamÁ|Ó»ó 
tcp_listenerÁdØ»netÁxÙ
TcpListenerStreamÁŒ–» 
(*
unix_listenerÁlÓ» 
IK
UnixListenerStreamÁ”ž» 
oq
splitÁ,Ì»io-utilÁ˜
SplitStreamÁ\滫"$
linesÁ,ü»«;=
LinesStreamÁ\ »«Z\ÀmacrosÁcfg_fsÁ cfg_io_utilÁcfg_netÁcfg_timeÁcfg_syncÁ
cfg_signalÁwrappersÁ
errorsÁ
 mpsc_boundedÁ       ¥æ 
into_innerÁcloseÁ ¥ poll_nextÁ size_hintÁ ¥É  ¥ as_mutÁ #¥#÷

mpsc_unboundedÁ'''''''.¥.æ .æ.÷'3¥333¥'8¥8É';¥;Ò'>¥>÷

stream_extÁBBB£EEEEEEEEEEO'aÁOStÁOOæ ETíTT°TŠ BBºZZZZZZZZZZdädíddæ Ziíii°iŠ BBchainÁooooooooox¥x¦xæ o|¥|¦|||¥BBcollectÁ 
 
FromStreamÁ¥¥¦æ ¥¦°Š žInternalCollectionÁž
initializeÁžextendÁžfinalizeÁ£¥¥¥¥Â¥Ü¥î¥ü«¥­¥­Â­Ü­î­ü³¥ µ¥µÂµÜµîµü
»¥»¦» ¿¥¿¦¿¿Â¿Ü¿î¿üsealedÁÇFromStreamPrivÁÈ¥ÈÂÈÜÈîÈüÇInternalÁÎ
BBBBfilterÁÓÓÓÓÓÓÓÓÓÜíÜÜ×Óàíààæ Óäíääää¥BB
filter_mapÁëëëëëëëëëôíôô×ëøíøøæ ëüíüü¥üüü¥B BfoldÁŽíŽŽŽæ í°Š B
BfuseÁšššššššš¢¥¢æ 𥥥¥¥¥B BØ««««««««³í³³×«·í··æ «»í»»¥»»À Á »¥B B map_whileÁÅÅÅÅÅÅÅÅÍíÍÍ×ÅÑíÑÑæ ÅÕíÕÕ¥ÕÕÚ Õ¥B
BmergeÁÞÞÞÞÞÞÞÞæ¥æ¦ææ Þê¥ê¦êêê¥Þð¥ð¦BBó ôôôôôôôôôýäýíýæ ôí°Š BBskipÁí×íæ í¥ BB
skip_whileÁœœœœœœœœœ¥í¥¥×œ©í©©æ œ­í­­­­¥BBtakeÁ´´´´´´´´´½í½×´ÀíÀæ ´ÃíÃÃÆ Ã¥BB
take_whileÁÊÊÊÊÊÊÊÊÒíÒÒ×ÊÖíÖÖæ ÊÚíÚÚÚÞ ß Ú¥BBthenÁãããããããããìíìFutÁìì×ãñíñ¾)ññæ ãöíöö¾)ööö¥ü BBtry_nextÁÿÿÿÿÿÿÿÿÿÿäíæ ÿ¥í°Š BBpeekableÁ¥æ peekÁ   £¥££BB StreamExtÁ¨ó ¨»*ª¥ª¨Ø­¥­¨í °¥°¨ý(³³¾)¨˜"¦¨¸¨ º¥º¨Ú¨É&¨Ô'¿¨š$¨¥%¨£Ä¨ºÆ¨È¦¨ÌÊʨŒÍ¥¨timeoutÁ¨timeout_repeatingÁ¨throttleÁ¨chunks_timeoutÁ¨Å+BÔíBmerge_size_hintsÁadaptersÁÚÚÚÚÚÚÚÚÚÚ Ú
Ú Ú Ú
emptyÁéééééééð¥éò¥éô¥éâ0ö¥éø¥øøø¥ùšùˆšŠšŠŠŠ¥ onceÁšâ2¥Ÿ¥ŸŸŸ¥
  pendingÁ§§§§§§§®¥§°¥§²¥§ã3´¥§¥¥

stream_mapÁ¾¾¾¾¾¾¾¾¾¾ÈœÈ§ÈùËÈúÍÈæ È
with_capacityÁÈkeysÁÑÑ È¼ÔÔ È
values_mutÁ×× ÈcapacityÁÈÈis_emptyÁÈclearÁÈinsertÁÈremoveÁß¢È contains_keyÁᢾãœã§ãpoll_next_entryÁ¾çœç§ç>¾ëœë§ë next_manyÁîî ð ëpoll_next_manyÁ¾óœó§óóó¥¾ùœù§ùùü¥¾þœþ§þ
ƒƒ¢

COUNTERÁseedÁƒæ 
fastrand_nÁfastrandÁƒ thread_rng_nÁ  stream_closeÁ¤æ 柤ŸŸ¢ Ÿ¥¤  ReceiverStreamÁ¨¥¨innerÁ «¥«×'UnboundedReceiverStreamÁ®¥®ÿ;'±¥±×
intervalÁ´´´´´´´´´½æ ½æ´ÀÀÀ¥´ÄÉ´ÆÒ
´IntervalStreamÁÉÿ;´Ë×
read_dirÁÍÍÍÍÍÍÍÍÍÍ׿ ׿ÍÚÚÍÝÉÍßÒ
Í
ReadDirStreamÁâÿ;Íä×E AllFutureÁæäæíææstreamÁæ±æ_pinÁEíäíííí×Eòóäóíóò__assert_not_repr_packedÁ÷ä÷í÷ò
ProjectionÁû'__pinÁûäûíûûê?û±û€@ò
ProjectionRefÁƒAƒäƒíƒƒê?ƒ±ƒ€@óprojectÁAó project_refÁAò__OriginÁAäí__dummy_lifetimeÁê?±€@ò˜A˜ä˜í˜òMustNotImplDropÁòž¥ò ä í Z AnyFutureÁ¤ä¤í¤¤ê?¤±¤€@Z«ä«í««×Z°±ä±í±°Ó@µäµíµ°‹A¹A¹ä¹í¹¹ê?¹±¹€@°ÛAÁAÁäÁíÁÁê?Á±Á€@±¨BÉA±¿BËA°ÚBÍAÍäÍíÍÍŠCÍê?ͱ̀@°ÖAÖäÖíÖ°ßC°Ü¥°ÞäÞíÞoChainÁâ¥â¦â¬â­oçè¥è¦çÓ@ë¥ë¦ç‹AîAî¥î¦î¬î­çÛAôAô¥ô¦ô¬ô­è¨BúAè¿BüAçÚBþAþ¥þ¦þŠCþ¬þ­çA¥¦çßC犥猥Œ¦CollectÁ¥¦ê?
collectionÁ_outputÁ€@ ¥¦×œ¥¦œÓ@¡¥¡¦¡œ‹A¥A¥¥¥¦¥¥ê?¥“K¥¥K¥€@œÛA®A®¥®¦®®ê?®“K®¥K®€@¨B·A¿B¹AœÚB»A»¥»¦»»ŠC»ê?»“K»¥K»€@œÅAťŦŜßCœË¥œÍ¥Í¦ÍÓFilterÁÑíÑÑê?ѱÓÖ×í×ÖÓ@ÚíÚÖ‹AÝAÝíÝÝê?ݱÖÛAãAãíããê?ã±×¨BéA׿BëAÖÚBíAííííŠCíê?í±ÖôAôíôÖßCÖù¥Öûíûë FilterMapÁþíþþê?þ±ëƒ íƒ Ó@íƒ ‹AŠ AŠ íŠ Š ê?Š ±ƒ ÛA A í  ê? ±¨B A¿B˜ Aƒ ÚBš Aš íš š ŠCš ê?š ±ƒ ¡ A¡ í¡ ƒ ßCƒ ¦ ¥ƒ ¨ í¨ 
FoldFutureÁ« í« « « ê?« accÁ« ±« €@³ í³ ³ ³ ׸ ¹ í¹ ¹ ¸ Ó@½ í½ ½ ¸ ‹AÁ AÁ íÁ Á Á ê?Á óTÁ ±Á €@¸ ÛAÊ AÊ íÊ Ê Ê ê?Ê óTÊ ±Ê €@¹ ¨BÓ A¹ ¿BÕ A¸ ÚB× A× í× × × ŠC× ê?× óT× ±× €@¸ á Aá íá á ¸ ßC¸ ç ¥¸ é íé é šFuseÁí ¥í ê?šð ¥ð ךó ô ¥ó Ó@ö ¥ó ‹Aø Aø ¥ø ê?ó ÛAü Aü ¥ü ê?ô ¨B
Aô ¿B
Aó ÚB
A
¥
ŠC
ê?ó 
A
¥ó ßCó 
¥ó 
¥«MapÁ
í

ê?
±«

í

Ó@š
íš

A
A
í

ê?
±
ÛA£
A£
í£
£
ê?£
±
¨B©
A
¿B«
A
ÚB­
A­
í­
­
ŠC­
ê?­
±
´
A´
í´

ßC
¹
¥
»
í»
ÅMapWhileÁ¾
í¾
¾
ê?¾
±ÅÃ
Ä
íÄ
Ã
Ó@Ç
íÇ
Ã
AÊ
AÊ
íÊ
Ê
ê?Ê
±Ã
ÛAÐ
AÐ
íÐ
Ð
ê?Ð
±Ä
¨BÖ
AÄ
¿BØ
AÃ
ÚBÚ
AÚ
íÚ
Ú
ŠCÚ
ê?Ú
±Ã
á
Aá
íá
Ã
ßCÃ
æ
¥Ã
è
íè
ÞMergeÁë
¥ë
¦ë
‘
­ë
a_firstÁÞñ
ò
¥ò
¦ñ
Ó@õ
¥õ
¦ñ
Aø
Aø
¥ø
¦ø
¬ø
­ø
Ð`ñ
ÛAÿ
Aÿ
¥ÿ
¦ÿ
¬ÿ
­ÿ
Ð`ò
¨B Aò
¿Bˆ Añ
ÚBŠ AŠ ¥Š ¦Š ŠCŠ ¬Š ­Š Ð`ñ
 A ¥ ¦ñ
ßCñ
 ¥ñ
 ¥ ¦ôNextÁœ äœ íœ ê?œ €@ô¡ ä¡ í¡ ×ô¥ ¦ ä¦ í¥ Ó@© ä© í¥ ‹A¬ A¬ ä¬ í¬ ê?¬ €@¥ ÛA² A² ä² í² ê?² €@¦ ¨B¸ A¦ ¿Bº A¥ ÚB¼ A¼ ä¼ í¼ ŠC¼ ê?¼ €@¥ à Aà äà í¥ ßC¥ È ¥¥ Ê äÊ íSkipÁÍ íÍ ê?Í  remainingÁÑ Ò íÑ Ó@Ô íÑ ‹AÖ AÖ íÖ ê?Ö ÂfÑ ÛAÛ AÛ íÛ ê?Û ÂfÒ ¨Bà AÒ ¿Bâ AÑ ÚBä Aä íä ŠCä ê?ä ÂfÑ ê Aê íÑ ßCÑ î ¥Ñ ð íœ SkipWhileÁò íò ò ê?ò  predicateÁœ÷ ø íø ÷ Ó@û íû ÷ ‹Aþ Aþ íþ þ ê?þ ÷h÷ ÛA A í  ê? ÷hø ¨BŠ Aø ¿BŒ A÷ ÚBŽ AŽ íŽ Ž ŠCŽ ê?Ž ÷h÷  A í ÷ ßC÷ š ¥÷ œ íœ ´TakeÁŸ íŸ ê?Ÿ Âf´£ ¤ í£ Ó@¦ í£ ‹A¨ A¨ í¨ ê?¨ Âf£ ÛA­ A­ í­ ê?­ Âf¤ ¨B² A¤ ¿B´ A£ ÚB A í ŠC ê? Âf£ ¼ A¼ í£ ßC£ À ¥£  íÊ TakeWhileÁÄ íÄ Ä ê?Ä ÷hÄ doneÁÊÊ Ë íË Ê Ó@Î íÎ Ê ‹AÑ AÑ íÑ Ñ ê?Ñ ÷hÑ ‹nÊ ÛAØ AØ íØ Ø ê?Ø ÷hØ ‹nË ¨Bß AË ¿Bá AÊ ÚBã Aã íã ã ŠCã ê?ã ÷hã ‹nÊ ë Aë íë Ê ßCÊ ð ¥Ê ò íò ãThenÁõ íõ ¾)õ õ ê?õ futureÁõ ±ãü ý íý ¾)ý ü Ó@
í
¾)
ü A
A
í
¾)

ê?
Žq
±ü ÛA
A
í
¾)

ê?
Žq
±ý ¨B
Aý ¿B
Aü ÚB
A
í
¾)

ŠC
ê?
Žq
±ü ¢
A¢
í¢
¾)¢
ü ßCü ¨
¥ü ª
íª
¾)ª
ÿTryNextÁ®
ä®
í®
ÿ;®
€@ÿ³
ä³
í³
×ÿ·
¸
ä¸
í·
Ó@»
ä»
í·
A¾
A¾
ä¾
í¾
ÿ;¾
€@·
ÛAÄ
AÄ
äÄ
íÄ
ÿ;Ä
€@¸
¨BÊ
A¸
¿BÌ
A·
ÚBÎ
AÎ
äÎ
íÎ
ŠCÎ
ÿ;Î
€@·
Õ
AÕ
äÕ
í·
ßC·
Ú
¥·
Ü
äÜ
íPeekableÁß
¥ß
,ß
ê?ã
ä
¥ã
Ó@æ
¥ã
Aè
Aè
¥è
,è
ê?ã
ÛAí
Aí
¥í
,í
ê?ä
¨Bò
Aä
¿Bô
Aã
ÚBö
Aö
¥ö
ŠCö
,ö
ê?ã
ü
Aü
¥ã
ßCã
¥ã
¥B‰/ 
  
¤æ ¤¥štwice_plus_oneÁœæ ž×¡÷B˜/££££££££££ £
£¯¤¯æ £²¤²²²¥BBBBBB±/¼¼¼¼¼¼¼¼¼¼ ¼
¼ ¼±/É¥¼Ë¥Ëget_refÁËget_mutÁËæ¼Ð¥Ðмis_zeroÁBBBBÁ/ØØØØØØØØØØ Ø
Ø Ø Øæ¤ææ æinto_remainderÁØê¤êêê¥î BElapsedÁñ
ñˆô×÷ ùÖÚÚÚÚéEmptyÁ
¥ˆé¥×IterÁˆšˆùˆ yield_amtÁŒšŒ×OnceÁ¥ù¥×§´
¥ˆ§¥×¾ StreamMapÁœœœ§œentriesÁ¾ œ § ×ƒFastRandÁ¤oneÁ¤twoÁƒ§×
THREAD_RNGÁ©__rust_std_internal_init_fnÁ© « ¬__RUST_STD_INTERNAL_VALÁ« ®ü‚StreamNotifyCloseÁ°¤°ÿ;³´¤³Ó@¤³‹A¸A¸¤¸ÿ;³ÛA¼A¼¤¼ÿ;´¨BÀA´¿BÂA³ÚBÄAĤĊCÄÿ;³ÉAɤ³ßC³Í¥³Ï¤Ø
ChunksTimeoutÁѤÑê?ÑdeadlineÁÑdurationÁÑitemsÁÑcapÁØØ¤Ø×ØÛܤÛÓ@Þ¤Û‹AàAà¤àê?àÚ…àê…àú…à‡†ÛÛAèAè¤èê?èÚ…èê…èú…臆ܨBðAÜ¿BòAÛÚBôAô¤ôŠCôê?ôÚ…ôê…ôú…ô‡†ÛýAý¤ÛßCÛ¥Ûƒ¤¼ThrottleÁ¥delayÁê… has_delayedÁê?¼¥×¼Ž¥ŽÓ@¥Ž‹AA¥މê…¤‰ê?ŽÛAšAš¥šމšê…š¤‰šê?¨B¡A¿B£AŽÚB¥A¥¥¥ŠC¥މ¥ê…¥¤‰¥ê?Ž­A­¥ŽßCޱ¥Ž³¥£TimeoutRepeatingÁµ¤µê?µá<£¹¤¹×£¼½¤¼Ó@¿¤¼‹AÁAÁ¤Áê?Áá<¼ÛAÆAƤÆê?Æá<½¨BËA½¿BÍA¼ÚBÏAϤϊCÏê?Ïá<¼ÕAÕ¤¼ßC¼Ù¥¼Û¤TimeoutÁݤÝê?ÝÚ…Ýê…Ý
poll_deadlineÁ
ã¤ã×æç¤æÓ@餿‹AëAë¤ëê?ëÚ…ëê…ëùŽæÛAòAò¤òê?òÚ…òê…òùŽç¨BùAç¿BûAæÚBýAý¤ýŠCýê?ýÚ…ýê…ýùŽæA¤æßCæ¥æ¤





"
2
6
6
6
7
:
=
T
X
X
X
i
m
m
m







¡
¢
©
ª
±
²
¹
º
Å
Æ
Ì
Í
ß
ß
ß
ä
è
è
è
é
÷
÷
÷




˜
˜
˜
¨
¨
¨
©



À
À
À
Ã
Ð
Ð
Ð
Ú
Ú
Ú
Ü
î
î
î
ï
ð
ð
ð
ð







˜
˜
˜

¨
¨
¨
­
±
±
±
²
¿
¿
¿
Æ
Æ
Æ
È
Õ
Õ
Õ
Ú
Þ
Þ
Þ
á
ð
ð
ð
û
û
û
ü




 
¦
¦
¦
©
ª
¸
¿
Â
Ä
Æ
û
û
û
ü



Ž
¢
¢
¢
£
¹
¹
¹
º
Ë
Í
Ñ
Ô
×
Ú
Û
Ü
Ý
Þ
ß
ß
á
á
æ
æ
æ
î
î
ò
ò
ò
ò
÷
÷
÷
ø



¢
¢
¢
¤
­
­
­
³
³
³
Â
Â
Â
Ã
Å
Ç
Ì
Ì
Ì
Ü
Ü
Ü
Þ
à
å
å
å
ñ
ñ
ñ
÷
¯
¯
¯
µ
ë



¡
Ú

·
·
·
½
ò
ò
ò
ö
š
Ç
õ
¤
¤
¤
©
Ô
û
¦
Î




»
æ



š
Ÿ
Ÿ
Ÿ
µ
µ
µ

Í
Î
Ó
Ó
Ó
é
í
í
í
î
õ
õ
õ
ø
ø
ú



Ž
Ž
Ž






£
£
£
¨
¨
¨

Ú
Ú
Ú
Þ




»
»
»
¿
å
å
å
é
¡8Ì8Î8Ò8Õ8Ø8ï8ï8ÛÊÈø¥ æ Œ
¸
å
Ç í ¿ ï §
Ù
ÿ
ˆØ°¨Ì¿c¨¨á;ªÿ; yI¤‡ç¡n|¥EÛŸàÛŸÙ>Ù>ReceiverÁÛ>chanÁ¹>éüä*–Kþˆ ãÛŸ£ éÛŸ£ ¿c®®Ÿ<°ÿ;'#†²´tè#ˆ E†¡à†¡ùAùAUnboundedReceiverÁûA¾ŸáA¤¾±MvEaˆ ã†¡Ì¡é†¡Ì¡¿cÉÉé=Êÿ;´°Aâ¹ö^vEµ¢àµ¢—W—WIntervalÁ˜WމÈU™WperiodÁÈUšWmissed_tick_behaviorÁÈU¸ä3rЇuãµ¢ø¢¿cââ˜?ãÿ;ÍYs°1žz…E÷£à÷£¯ ¯ ° ReadDirÁ± ˆÊ —üYrã÷£º¤¿cææÁ?êê?Eë±Eì€@Ev+b œÝXäí“íææÁ?êê?Eë±Eì€@Ev+b œÝXä툠‰¥‚ØææÁ?êê?Eë±Eì€@Ev+b œÝX8ҥإ¿c¤¤ŸD¨ê?Z©±Zª€@Zqý¢e|ÿ‡
äҥإ“í¤¤ŸD¨ê?Z©±Zª€@Zqý¢e|ÿ‡
䯦µ¦Ûˆ Û°§‚ؤ¤ŸD¨ê?Z©±Zª€@Zqý¢e|ÿ‡
8ҥإ“íââ…Hå¬oæ­o ldŒ—¥¦ˆ ââ…Hå¬oæ­o ldŒ—ˆ ¦E¦ª¿cäJê?“K¥K€@aÕ'‡£¿ˆ âª“íäJê?“K¥K€@aÕ'‡£¿ˆªŽªÊˆ Êùª‚ØäJê?“K¥K€@aÕ'‡£¿ˆ âªâªˆ FÊÈúHúHßûHÁ‘4Ý­f‰úM÷ˆ Èï­ˆ ªBªBö­BbufÁ÷<®B÷<9)
-ÜnLˆ çEçEèEGlobalÁ ¿±‡§í#ˆ È·®ˆ žBoxÁ¡ˆˆ¢ˆl }.xÏ
ˆ ø®ˆ È¾¯ˆ Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
âªÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ˆ ô°È¢°ú°“íÑÑüNÔê?ÓÕ±Ó‹èҥإøˆ øÑÑüNÔê?ÓÕ±Ó‹èí¿c»²E»²“íþþÝQ ê?ë±ëï±ÞÉu^ƒrҥإ¥ ˆ ¥ þþÝQ ê?ë±ëï±ÞÉu^ƒrõ²û²¿cò³Eò³¿c« « ÁT¯ ê?° óT± ±² €@bìMŒ‡žÛõ²Ø¥“í« « ÁT¯ ê?° óT± ±² €@bìMŒ‡žÛÒ¥µ¦æ ˆ æ д‚Øд¿cí í ÎXï ê?šéË}š–gˆ “íí í ÎXï ê?šéË}š–gˆªŒ
ˆ Œ
Á¶EÁ¶“í

âZ
ê?«
±«Nç
z8³Ò¥Ø¥¸
ˆ ¸


âZ
ê?«
±«Nç
z8³õ²û²¿c©¸E©¸“í¾
¾
À]Á
ê?ÅÂ
±Å›}­?ÜŸéҥإå
ˆ å
¾
¾
À]Á
ê?ÅÂ
±Å›}­?ÜŸéõ²û²¿cܹEܹ“íë
ë
£`î
¬Þï
­Þð
Ð`Þ+Í½ŠŽ(,؈ªŽª ˆ  ë
ë
£`î
¬Þï
­Þð
Ð`Þ+Í½ŠŽ(,؈ âªE›»¿cœ œ ªcŸ ê?ô  €@ô³\~PL­œWäÒ¥“íœ œ ªcŸ ê?ô  €@ô³\~PL­œWä¯¦Ç ˆ Ç ú»‚Øœ œ ªcŸ ê?ô  €@ô³\~PL­œW8Ò¥“íÍ Í ¦fÏ ê?Ð Âfʲ~ŸÚ†ÙÒ¥í ˆ í Í Í ¦fÏ ê?Ð Âfʲ~ŸÚ†Ùõ²¿cþEþ“íò ò Îhõ ê?œö ÷hœ¶bÖå)•¢ßҥإ ˆ  ò ò Îhõ ê?œö ÷hœ¶bÖå)•¢ßõ²û²¿cò¿Eò¿“íŸ Ÿ »k¡ ê?´¢ Âf´Ð;¹dÌ-^ÍÒ¥¿ ˆ ¿ Ÿ Ÿ »k¡ ê?´¢ Âf´Ð;¹dÌ-^Íõ²¿c¡ÁE¡Á“íÄ Ä ÚmÇ ê?ÊÈ ÷hÊÉ ‹nÊ„uÞDÚMFÒ¥Ø¥ï ˆ ï Ä Ä ÚmÇ ê?ÊÈ ÷hÊÉ ‹nÊ„uÞDÚMFõ²û²¿cÜÂEÜ“íõ õ âpù ê?ãú Žqãû ±ãMC‚*xE¸žÒ¥¾)µ¦§
ˆ §
õ õ âpù ê?ãú Žqãû ±ãMC‚*xE¸žõ²¾)Ø¥¿c­ÄEõ õ âpù ê?ãú Žqãû ±ãMC‚*xE¸žõ²‘Äû²¿c®
®
§t±
ÿ;ÿ²
€@ÿÃξÓU¤iäÒ¥“í®
®
§t±
ÿ;ÿ²
€@ÿÃξÓU¤i䯦Ù
ˆ Ù
ëłخ
®
§t±
ÿ;ÿ²
€@ÿÃξÓU¤i8í“íß
ß
¦wá
,â
ê?­ÙÍÇÒà•ˆªÿ
ˆ ÿ
ß
ß
¦wá
,â
ê?­ÙÍÇÒà•ˆ E¶È¿cÝÝÈŽßê?àÚ…áê…âùŽ Û…ì^e¦¤“íÝÝÈŽßê?àÚ…áê…âùŽ Û…ì^e¦¤ˆˆ ˆ…É¿cññòý~óˆ Éä”aÍÇùâÐìâʵßâÊâÊâÊE…ÉÄcâʾâÊéßßErrorÁà ¬
ÑøÿËO ŸâÊ¿cµµˆŒ·ê?£¸á<£? è…q®XfÛÉ“íµµˆŒ·ê?£¸á<£? è…q®Xf¿Ê؈ Ø ÌE Ì¿cöˆމ¼ˆê…¼¤‰¼Šê?¼²Dý&ž)Jˆ “íöˆމ¼ˆê…¼¤‰¼Šê?¼²Dý&ž)Jˆª°ˆ °ÍÍEÍÍ¿cÑѵ…Óê?ØÔÚ…ØÕê…ØÖú…Ø×‡†Ø¯ó<{6¹ÛÉ“íÑѵ…Óê?ØÔÚ…ØÕê…ØÖú…Ø×‡†Ø¯ó<{6¹¿Êˆ °ÏE°Ï¨õ²¿cáˆé =ú|ïVM–6ˆ “í¸ÑÌì¸Ñ ¸ÑE¸Ñ¿cˆˆ˜€Šù´€> Ó…”Çš“í¢ÒE¢Ò¿cÚ€ù|Á'ˆ “íÚ€ù|Á'ÞÒEÓ¿c´˜ˆ§ §ò€Ãn§uˆ “í€ÔÌì€Ô €ÔE€Ô¿cœœ½ŸÞ¾Ú¢~‹˜p#8œ§³êÔEêÔÃLêÔšÕ ÕÐLêÔÆÕ¿c¤¤Š‚¥š‚ƒ¦¥‚ƒ–c·1È•v“í°°©ƒ²ÿ;?¤ïü„vfÞ¿Ê̈ Ì°°©ƒ²ÿ;?¤ïü„vfÞÛÉEïÖ«¨±®ËÉäâíæ«¤ÜÑôþ³ « ð í ³
;
¡ œ Í ¥ò ½Ÿ ÒÄ ìõ ³
®
ãÝôñ¹µØÑŒˆ œ§¤¨3®ÀÉÚâ|âäÑüþ¥í »
Õ¾
êë
Í ­ò ß ÚÄ öõ £ß
ݲµÐêÑøŠˆŸóœŸ°¨8®ÄÉÝâ ¨;®ÆÉßâ#¨>®¡ß˜æÖ¤âÅôÑ¡ þá « ‰
í ´

á
¾
ë
à œ ê Í ò ¼ Ÿ ë Ä ¢
õ Õ
®
ü
ß
ÝÕµ­ýÑðˆ®É°ž æTæi¤« œ ®
ÜÞ¤ŠŒâËÍ
£úH«ªB³»Ö¿ž
¥úH­ªBµ¿Ö¿ùûѦ ¨ þç é «
í ¹
»

æ
è
¾
ë
È Ê œ î ð Í š œ ò À  Ÿ ð ò Ä ¨
ª
õ Ú
Ü
®
ß
Ýöñ÷ñùñžñ ñÙÛµ±³ƒÑÔò°ô²çœùœþœÍϰ¿cÑEÙàºãé“íÄ‚Ø
Û(
Ê

È"ø"¥ 
æ 
Œ

¸

å


Ç 
í 

¿ 
ï 
§

Ù

ÿ

ˆ
Ðì
µßÄc¾Ø°

¨
Ìì ³ÃLÐLÌü”« ¢ˆ “ؓؔØÎ•؈ä o
³΢½Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ À­ ¶È®» ÕÉäÉäÉäÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÀ­ Éä²åÛÀ­ Û¼ÀäüžÉä
©¶È3Š 
ˆØœ œ ªcŸ ê?ô  €@ô³\~PL­œW¶ÈaˆÇþÃç Ã瞣
öX Ãç ¸ÁÅ
Ò×
„ØÃçê
Šøü  
  œØûã7Cå ȲåÉä²å 
,Éä@²å LÉä²å
©TÀ­E¥Éä¹²å  Ž¿ œØûã&lx

Ž£ ©¾ Äó¢èøÈ«ü¾ øÿ "%"
ÆŽ
" 1( Ⱦ  0§¯½ÄÍ×
®µãêýòù# µã ÌÌkÎwakerÁ¸Ï local_wakerÁ¸ÐextÁ¸Ñ_markerÁ¸Ò_marker2Á¸f'EwÚ]¾å±ÉäiÀä`ÀäѲåŒþÃçÞÃçÉä4Ãç  œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã²åW„¾„¾PinÁ†¾ ˜X$]È=„kt•ÜèÜèÜè¦ÄïJÄïSÄïÁɲåmtÄïâê ²åEÓÛãëóûûã:BþMÉä°ÉäitÁûÃç 2«¼Ê œØàë
¢ú

œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ãg µãp Äïy  Éä×Ãç)ûsw°œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ãûã
„¾„¾–ñ†¾ ˜X$]È=„kt•³ãM
ÄïV
 ÀäûÃçeÃçš¼ñwŠòÜèÄïš²å>Äï¬óûãÉ
Ñ
³ãÚ
Éäã
Éäì
Éäõ
Éäþ
Éä Éä Éä þ$ ×ÉäÉä óê ûòÃç    ç¬ ¼çÖèŽ Šé²å<—ëÈÉäÃçU û,ž¢Û Éä:ÃçŒ ûcÕÙ
\ÿ ˆ ”ù ˆ  ŠöüÏ>¸Ñ PhantomDataÁFu\»Ÿˆ Q ˆ ¤õ ˆ  ˆ´üÇD€ÔÙüj ü™‹J ðšÕ ÕÂã êÔ ªBªBö­BÊ­÷<®B÷<9)
-ÜnLšÕ ÕFø®
׊ÏþâŠÕþ‚‹ü«‹+ ñšÕ Õ ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÏþÕþ ü£‹4<£‹
Ç€ñšÕ ÕÀ‘‚O
AØ‹

ˆØÊ€Ê€PollFnÁÌ€±À€¡Ab«SÁhÆ‚œ
^øâ£‹:ˆƒ~ ˆƒ¢
öX ˆƒ ·

ÀÄ ÑÖ
„؈ƒ
é Œ 
÷û
 
 Ã
! œØ7Cè Èã‹ œØ&Ýé𪸠 / 5
ðPøã™‹J # áÜ‹  â‹ãâ‹ 
áêó=#*3=
®²þP  ²þŠÄïÏþL׊Õþ4âŠ,‚‹ˆƒjˆƒºÆ‚ÛÏþäÕþ홂öˆƒ>ú°Æ¹„¾„¾–ñ†¾ ˜X$]È=„kt•Ÿ„ôŸ„ýŸ„Äï­ÄïÄï!)ÏÖÄïAI£« þ$ÜŠÏþbufferÁ4ÕþlimitÁAfóŠh‹‹kû|ˆƒ N_m œØƒŽ
ðMT[fmÂõͲþÖÄïßçEˆƒJ‹‹û™‹jnÑÆ5„¾„¾–ñ†¾ ˜X$]È=„kt•°þpÄïyÏþæÕþ䈃BˆƒÆ‚³™‚¼Æf°ŠoŸ„xÄï/Äïšô°þý þ RÏþóŠÕþ‹‹ˆ­óН‹‹²ûȃ ؼ‚ƒU™„\Í„cóŠ‹‹ˆƒ‹‹ûÕ=A¤RˆƒW‹‹û
uyÜùï·e
éï·e
¾åÕùïÕúe«Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙåÕ åÕ’“µæùîfa©®®£°ÿ;¨it§ÅLS¶åÕáî¢fa["«’“’“ùïðe
éïðe
ÐåÕ28ù瑩e
 ¬—“«”2’“ ï¿eùïíÔeùï‚!­e
 ®¨–%’“ ï!eR ïÀ$eùïÛôe«’“!$¬¨–󮨖¨W”¢ ñò%âÊ18?œÜ ˆ )¸Ñ5Ùü=D¬à ˆ )€Ô5Ùü=D
é§¾ÀרÈ,Lñ¨Ùâ0,¬ öþáÿù ˆ˜€ˆâ2$ü ¥Ú€$‚¦ã3<© ´¼´½½œ©ƒŒ•°¦StreamÁ4ÑE§ÈŽÝÿý~<…ñüØüù Stream utilities for Tokio.ÁúüMJ A `Stream` is an asynchronous sequence of values. It can be thought of asÁüëGD an asynchronous version of the standard library's `Iterator` trait.Á³úü·\Y This crate provides helpers to work with them. For examples of usage and a more in-depthÁü”=: description of streams you can also refer to the [streamsÁüÒLI tutorial](https://tokio.rs/tokio/tutorial/streams) on the tokio website.ÁŸúì£ # Iterating over a StreamÁÁúüÅNK Due to similarities with the standard library's `Iterator` trait, some newÁü”HE users may assume that they can use `for in` syntax to iterate over aÁüÝLI `Stream`, but this is unfortunately not possible. Instead, you can use aÁüª  `while let` loop as follows:ÁËú ```rustÁüÛ2/ use tokio_stream::{self as stream, StreamExt};ÁŽ úü’ /, # #[tokio::main(flavor = "current_thread")]Á¼Â  # async fn main() {ÁüÚ 1. let mut stream = stream::iter(vec![0, 1, 2]);ÁŒ
úü
1. while let Some(value) = stream.next().await {ÁüÂ
" println!("Got {}", value);Á

 # }Á
 ```Áû
úüÿ
(% # Returning a Stream from a functionÁ¨ úü¬ JG A common way to stream values from a function is to pass in the senderÁü÷ PM half of a channel and use the receiver as the stream. This requires awaitingÁüÈ GD both futures to ensure progress is made. Another alternative is theÁü
NK [async-stream] crate, which contains macros that provide a `yield` keywordÁüß
-* and allow you to return an `impl Stream`.Áúü‘0- [async-stream]: https://docs.rs/async-streamÁÂúüÆ52 # Conversion to and from `AsyncRead`/`AsyncWrite`Áüúü€FC It is often desirable to convert a `Stream` into an [`AsyncRead`],ÁüÇMJ especially when dealing with plaintext formats streamed over the network.Áü•IF The opposite conversion from an [`AsyncRead`] into a `Stream` is alsoÁüßC@ another commonly required feature. To enable these conversions,Áü£EB [`tokio-util`] provides the [`StreamReader`] and [`ReaderStream`]Áüé)& types when the io feature is enabled.Áúü—QN [`tokio-util`]: https://docs.rs/tokio-util/latest/tokio_util/codec/index.htmlÁüéC@ [`tokio::io`]: https://docs.rs/tokio/latest/tokio/io/index.htmlÁü­MJ [`AsyncRead`]: https://docs.rs/tokio/latest/tokio/io/trait.AsyncRead.htmlÁüûOL [`AsyncWrite`]: https://docs.rs/tokio/latest/tokio/io/trait.AsyncWrite.htmlÁüË^[ [`ReaderStream`]: https://docs.rs/tokio-util/latest/tokio_util/io/struct.ReaderStream.htmlÁüª^[ [`StreamReader`]: https://docs.rs/tokio-util/latest/tokio_util/io/struct.StreamReader.htmlÁü® üÐ"|”
é§¾ÀË ×Ì ØÈ,Ë ¨Ùâ0Ê öþáÉ ÿùÈ ˆ˜€Ç ˆâ2Æ ¥Ú€Å ¦ã3Ä ´¼´à ½½ œ©ƒÁ °¦¤›» E§ÈŽº Ýÿý~¹ ñÝ
à
ã
T—4œ4
  »  ),   ', 8÷$& "8÷$#
(*+ . ¹, 8 9 ²+ G H \8âI L [8»<M U7fsÁ$W+ j k 8äDl t 8docsrsÁ4u$ {8Ó}  8â  8»<… 7ݶ$, ¤8÷
³ľ × ˆ Ý ì, Þ ß ê, à8÷& å8÷
ë*î ñ , û ü ÿ+ Š  ¤8⌠ £8»< ˜7«+ ² ³ ã8ä ¼ â8‘·$ Ã8ÓÅ È á8âÉ Ì à8» Õ7«, ñ8÷
¤‹   É ¦ µ, § ¨ ³, ©8÷& ®8÷
´*· º Ç, Ä Å À+ Ó Ô é8âÕ Ø è8» á7 
+ ÷ ø ¤8ä  £8‘·4‚$ ˆ8ÓŠ  ¢8⎠ ¡8»< š7 
, ²8÷
Á¬Ì â  è ÷, é ê õ, ë8÷& ð8÷
ö*ù ü ,   +   ¬8â š «8»< £7timeÁ+ º » è8ä Ä ç8‘·$ Ë8ÓÍ Ð æ8âÑ Ô å8» Ý7Å¿, ö8÷
¬D ¦ Ñ ¬ », ­ ® ¹, ¯8÷& ´8÷
º*½ À Ï, Ê Ë È+ Ù Ú ð8âÛ Þ ï8» ç7ç+ þ ÿ ¬8äD€ ˆ «8‘·4‰$ 8Ó  ª8â ˜ ©8»<™ ¡7ç, º8÷
É¼Ô ì  ò , ó ô ÿ, õ8÷& ú8÷
*ƒ  ,   + Ÿ   ¸8â¡ ¤ ·8» ­7ó + Æ Ç ö8ä Ð õ8‘·$ ×8ÓÙ Ü ô8âÝ à ó8» é7ó , 8÷$… 
„¤ü52 Wrappers for Tokio types that implement `Stream`.Á '´Íá;tñ¨&Ÿ<¼®®Aé=tœÉȘ?l„
âátYü7! Error types for the wrappers.Á4a„É
¨¤›4 E 
§–ñ!„¾ k<6Ì ·$?œØ ­ŸD]Ù> lalPL*CE46ÜJ'Ìç¥Í술 ìÛŸü®%ü‡" Create a new `ReceiverStream`.Áµ£ ÛŸ
ˆ recvÁ$¹ü¥ &üþ" Get back the inner `Receiver`.ÁT¬ ÛŸ£ 
ˆ ¼ù
üì ?< Closes the receiving half of a channel without dropping it.Á°
úü¸
KH This prevents any further messages from being sent on the channel whileÁüˆ HE still enabling the receiver to drain messages that are buffered. AnyÁüÕ FC outstanding [`Permit`] values will still be able to send messages.Á  úü¨ KH To guarantee no messages are dropped, after calling `close()`, you mustÁüø ?< receive all items from the stream until `None` is returned.Á¼
úüÄ
0- [`Permit`]: struct@tokio::sync::mpsc::PermitÁ,€ ÛŸ 
ˆ $‹ü¸$¥×Ê ½ÛŸFGHˆ ü÷XŽ„¾„¾–ñ†¾ ˜X$]È=„kt• ŽÛŸ ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÛŸF 
ˆ cxÁžüÝ-üþFC Returns the bounds of the stream based on the underlying receiver.ÁÉúüÑ;8 For open channels, it returns `(receiver.len(), None)`.Áúü™KH For closed channels, it returns `(receiver.len(), Some(used_capacity))`ÁüéEB where `used_capacity` is calculated as `receiver.max_capacity() -Áü³HE receiver.capacity()`. This accounts for any [`Permit`] that is stillÁÜ€ able to send a message.Á úü¨0ôÏ ÛŸÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ê
ˆ ü0¥×Ê ÛŸâü¸  ÛŸ £  Â
ˆ üø0¥!!×Ê ýÛŸ"å"ü¯( ÛŸ £   ¹
"ˆ üû/¥$$×Ê ÛŸ%ë%ü±"$´£ ÛŸ##
%ˆ éÊäã ”‚t†
®¤›4 E'(§–ñ! „¾')k<6 Ì'+·$? œØ',Ö Œ] ùA'-l al PL* CE46üJ$ (ü¬" ¥//×Ê ± †¡012ü… . üÕ+ ( Create a new `UnboundedReceiverStream`.ÁŒ Ì¡†¡..
0ˆ éÊ$ üŽ
/ üÞ + ( Get back the inner `UnboundedReceiver`.ÁT•
†¡Ì¡..
1ˆ $ 
¼Ã üÞ
? òË¢ úüª K ÇÌüú D A still enabling the receiver to drain messages that are buffered.Á,Ê  †¡. Ð .
2ˆ  ü‚
- ¥44×Ê
†¡567FGH67
33ˆ üÊ
X LÍ
„¾„¾–ñ†¾ ˜X$]È=„kt• †¡ ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ†¡F3 å
3
6ˆ 
ûÔñ
ü¸- üÑF “Õœ úü¤; ïÕä úüìG D For closed channels, it returns `(receiver.len(), receiver.len())`.ÁL» ˜ ˜†¡–Ú3 Å 3
7ˆ  üšB ¥99×Ê Ÿ †¡:â:üã) 4æ  †¡ Ì¡8 í 8
:ˆ  ü¬B ¥<<×Ê ± †¡=å=üõ1 4ø š š†¡ šÌ¡; ÿ ;
=ˆ $„ üÊA ¥??×Ê Ï †¡@ë@ü’+ $• Ì¡†¡>>
@ˆ éÊ üž'6EZo„Óëš«ÅÞôœ´Êãÿ¨Ö£¼ØFutureÁ4
‚ØBC¤›4,
EBDÁ?LG
æBYŸDLe
¤Bn…H,
âƒäJ<¹
BÑ×
BÒüN4ì
ÑêÝQL™
þƒÁTT¹
« BÎX$Þ
í ªâZû

ÄÀ]D£
¾
Ý£`,È
ë
óªc$ä
œ B¦f$ƒ
Í ÎhL®
ò ³»k$Ò
Ÿ ÉÚmLý
Ä ââp$¡
õ þ§t<Ä
®
B¦wDî
ß
§ÈŽ
Ý·ˆŒ„„
µ¸DurationÁD¬
­ÖBº‚¢
—WB»±/Dæ
ÉBÖöˆ
B×µ…
Ñð¤
+¤
<5
9
ò¤›4 EEF§Áì4& ‚ØEG
PhantomPinnedÁl@ ”íEH¶ñ•íEH–ñ^ „¾EIreadyÁ,t ¥‚EKk<{ ÌEL·$„ œØEM pin_projectÁ\¡ ENl Ϥ ¾Ü2 £tS Tg ln]_N 7ü·, äPíQRPQRÎìÒ¥À ÍìØ¥ Ì ‰¥S¼ !#üê3 ø B äҥإ‰¥OO
Säҥإê?4ü ±  ü†r 8íUVVUØ¥Ò¥F˜" Êô  EÒ¥ “íÒ¥ “"Ø¥¢ö¼à ¹ô Ù¦WXƒØ„ØXbd\ÿ 4„ TTü˜I $ œž„¾„¾–ñ†¾ ˜X$]È=„kt• œÙ¦ ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åžœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÙ¦ƒØT ª T
X8ҥإ ûÔ tB
H<S
W
°¤›4 EZ[§Áì4& ‚ØZ\¶ñl@ ”íZ]¶ñ•íZ]–ñ^ „¾Z^ÿñ,t ¥‚Z`k<{ ÌZa·$„ œØZb¾ò Zcl µ¤ ¤Ü2 •tS qTg bdSUD 7ü·, äeífggef¹ôÀ Êô Ì °§h¼ üê3 ø B£õØ¥°§dd
häҥإê?4ü ±  ü†r 8ŸíjkjkŸšö Êô  ¿ö Îö ßö¼à ¹ô ø¨lmƒØ„ØmFH\ÿ 4„ iiü˜I $  ¡¢„¾„¾–ñ†¾ ˜X$]È=„kt•  ø¨ ¡ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾å¢œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ãø¨ƒØi ª i
m8ҥإ ûÔ t`

Lq
,u
çÎX$
í opª¤›4(
Eoq§–ñ@
„¾orÿñ,V
¥‚otk<]
Ìou·$f
œØov¾ò
o
Žl!
|t5
kTI
\^MO>@ìq
1´Ð
¥y¦zyz×Ê Õ
Íì⪠Ø
¦ª{üí\
û
Bˆ âª¦ªxxEˆ 
Eâª
{ˆ âª¬ ÿ
­ 
üþU
¥}¦~}~âªFÀ­
 
ì„4­
û„´¼
×Ê ƒ
¦ªFGH!#FH

||À­üôQ

£¤¥„¾„¾–ñ†¾ ˜X$]È=„kt• £¦ª ¤ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾å¥¼ñ| 
|
ˆ âª$
ûÔ


üŽ-
L
¦ ¦¦ª–Ú| 
|
ˆ âª
d„
È
´“

Çœ¤›4 E§Áì4&‚Øçû\Aˆçûˆ¶ñlN”í¶ñ•ííh늖ñ|„¾ÿñ,’¥‚k<™ÌŽ·œØ¾ò\¿l¤öd2åç¾ÀLb™tq‰T…y{giUWì­FüÊ2ôÎ Convert from a [`Stream`].ÁíúüñA> This trait is not intended to be used directly. Instead, callÁü³85 [`StreamExt::collect()`](super::StreamExt::collect).Áìú”ð # ImplementingÁƒúü‡OL Currently, this trait may not be implemented by third parties. The trait isÁü×KH sealed in order to make changes in the future. Stabilization is pendingÁü£&# enhancements to the Rust language.Á¥ÎìüÊ5È»ˆªÌãÍ숪 ß³>Æ/³JÆ;-/ü `¥¦×Ê  ì„âªÀ­œÍ ߬/146üè Dö Bˆ ߬
ˆ âªê?4ú ü½ k¥˜¦˜×Ê   Å ì„4…
摜”
߬šƒØ„Ø469;
4´
âªüÅ
B
§¨©„¾„¾–ñ†¾ ˜X$]È=„kt• §߬ ¨ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾å©œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã⪠Û

ˆ âª
ûÔç
\–Ô¦üÅ&Ÿ ¡¢ÊËÌÍ¢ ¡¼ò”÷žžü•HÎÎÏà Þ~x’ ’e¸šÚžž
  £_lowerÁ4¸_upperÁ4ÇüæGªõ— ªž ž
¡ ð _collectionÁ\…_itemÁ,üÈ6«õ— «ž öž
¢ Ô³˜ü…,¥¤¤×Ê Šàˆ Tï­ü¶8¥¦¦×Ê »ךï­§¨©ªÊËÌͪ¨©8:¼õ”ú¥¥ï­üœRõ—šÚï­¥¥
¨ˆ  ªÀ—4¿Ηü’H4•¬õ— ¬ï­ˆ ¥ ½¥
©ˆ  œ“KT±÷ü¡C­õ— ­ï­ï­¥ Î¥
ªˆ  ­“KTÂüŽ ¥¬¬×Ê ·®
ü³,¥®®×Ê ¸·®¯°±²ÊËÌͱ²°02¼æ”ë­­·®üQTõ—šÚ·®­­
°ˆ  lowerÁ,°ΗüŽH4‘®õ— ®·®ˆ ­ ¹­
±ˆ  ˜“KT­÷üCD“¯õ— ¯·®·®­ ½­
²ˆ  œ“KT±üý"¥´´×Ê ¾¯
ü¤.¥×Ê ©¾¯·¸¹ºÊËÌ͹¸º02¼Ù”Þµµ·®ü€Põ—šÚ·®µµ
¸ˆ  Ž©ŸupperÁ,±ü¸H°õ— °·®ˆ µ ãµ
¹ˆ  “KT×÷üè E±õ— ±·®¾¯µ •!µ
ºˆ  ô “KT‰!ü¯"N¥¼¦½¾½¾¼×Ê ´" ·"Íìô° º"⪈ lð"¢°57:<68ü‚#_¥À¦ÁÂÂÀÁ×Ê ‡# Š#¦ #Ó¦lÓ#¢°ÃÄÅÆÊËÌÍÅÄÆHJMORT¼è#”í#¿¿Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
⪈ Êô°ü©$‰T¬$õ—šÚר¿¿
Ĉ âªô° À$©Ÿ,Ý$—£,ó$üú%„4ý%²õ— ²¢°ú°Êú°¿ ¶&¿
ň âªô° &“KTª&÷$Ý&üï)[Dò)³õ— ³Ôª¢°¿ œ*¿
ƈ âªô° û)“KT*¬ï,4þ,ÈÎÏÜž-4‘-t¨-È¥ÉÉȳüž-Ú ·-ȳ"³ËÌÍÊËÌÍÍ컈ªÊÄÖ.°­ÍËÌce¼Ö.”Û.ÈÈüž/‘T¡/õ—šÚ¸­ÈÈ
Ë»ˆªåD¹/©Ÿ,Ù/—£,ó/üÌ1Z4Ï1´õ— ´¸­ˆªÈ ö1È
Ì»ˆªåDÖ1“KTê1÷$•2üâ2SDå2µõ— µ¸­»È Ž3È
Í»ˆªåDî2“KT‚3œí3Dø3õ—Þ~x’ ’e¸Ï-)ÎÎõ—
!!q!t!TÐ

Ö¤›4 EÓÔ§× `ÓÕ–ñ2„¾ÓÖÿñ,H¥‚ÓØk<OÌÓÙ·$XœØÓÚ¾ò\uÓÛlL„t'tT;ceRTACìc2üìBíÝÞÝÞÍìõ²ñÍìû² õ¿cõ²»²ßÀcß4602üµ8¸·¸ »² · c cˆ¢cµ
 `£cÊ­ `àB¤GS
¸Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ ÈìÊ éBLÜ ¼Ü
ßõ²û²± ÃÌÛíáââ᧳ำ 仲ãüû+Bõ²û²»²àà
ãõ²û²ê?4± üÍ[íåæåæ¹û² ¹õ²F˜"¸³ ÖEõ²4€¹“"û²§¸Ä§³Ò»²çèéFGHèé"$_aä䲸üÊVº»¼„¾„¾–ñ†¾ ˜X$]È=„kt• º»² »ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾å¼œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ²¸ä åä
èõ²û²ûÔñüƒ
-L†
½ ½»²–Úä
ä
éõ²û²$

”'tõ

ƒ ¤›4 Eëì§× `ëí–ñ2„¾ëîÿñ,H¥‚ëðk<OÌëñ·$XœØëò¾ò\uëólL„t'tT;ceRTACìc2ü÷Eíõöõö§³ü¸³ ɳò³÷Àc÷#%(*üÃ8ƾ¿À ¾ò³ ¿ c cˆ¢cµ
 `£cÊ­ `àB¤GS
À‹µô Êô
÷õ²û²± Ñäìíùúúù§³ñ¸³ õò³ûü+Bõ²û²ò³øø
ûõ²û²ê?4¡± ­üáeíýþ¥ÿýþÿû²²¸˜"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¥¸³ êÍì¢Ä íθ“"û²ÔÃä©§³æò³FGH"$df`büü¢ÄüáOÁÂľ„¾–ñ†¾ ˜X$]È=„kt• Áò³ ÂÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åÜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÝÃü üü
õ²û²¢ÄûÔˆü 
-
Ä Äò³–Úü ­
ü
õ²û²¢Ä
¬
?-D¥

B« ¸ ¤›4 E§Áì4&‚ضñl@”í¶ñ•í–ñ^„¾ˆÿñ,t¥‚Šk<{Ì·$„œØŒ¾òlǤ´Ü2£tS{TgjlY[H9üØ#í§³ÝÍ즵 áÊô äд$& "%'ü‚4Bõ²¦µØ¥дŽŽ
õ²¦µØ¥ê?4”initÁ$ ± ©ü¼díØ¥¦µ²¸˜"¦µ žæË ÅÊô Èθ“"Ø¥Þͼˆ§³Áд˜ƒØ„Ø˜UWZ\¦µü½IÅÆÇ„¾„¾–ñ†¾ ˜X$]È=„kt• Åд ÆÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åǜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃдƒØ Ï
˜õ²¦µØ¥ûÔÛ„³
ˆ1DÆ

Bí ó ¤›4 Eš§¾ò\*šœ–ñE„¾šÿñ,Z¥‚šŸk<aÌš ·$jœØš¡l‚ìol;_LNNP=?,.ü¡$¥££×Ê ¦ì„Á¶¤üÌ'Úˆ Á¶¢¢
¤ˆ ê?4Þüº/¥¦¦×Ê ¿ì„Á¶§¨©FGH©¨*,¥¥À­üŠULÈÉÊ„¾„¾–ñ†¾ ˜X$]È=„kt• ÈÁ¶ ÉÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åʼñ¥ ¥¥
¨ˆ $›ûÔ±üÑ-Ë ËÁ¶–Ú¥ Þ¥
©ˆ 
£4<å
é
B
¤›4 E«¬§× `«­–ñ2„¾«®k<HÌ«°·$QœØ«±¾ò\n«²lLmt']T;NP=?ì\.üÔ?í´µ´µ§³Ù¸³ Ýɳ©¸Àc#%(*üš8ÌÍÎ Ì©¸ Í c cˆ¢cµ
 `£cÊ­ `àB¤GS
΋µ³ ¡³
õ²û²± ¨´£í¸¹¸¹§³¨¸³ ¬©¸ºüÀ+ÎBõ²û²©¸··
ºõ²û²ê?4Ò± Þü‘Wí¼½¥¾¼¾½û²ÔØ"¢Ä 渳 š´Ä θÍĤӧ³©¸¿ÀÃFGHÃÀ"$OQTV»»¢ÄüƒOL†ÏÐÑ„¾„¾–ñ†¾ ˜X$]È=„kt• Ï©¸ ÐÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åÑ·Ç» ž»
Àõ²û²¢Ä$”ûÔªÀ<closure_kind>ÁÁ<closure_signature>ÁÁ<upvars>ÁÁÁÀÁõ²û²¢Äƒ¼Ýà „¾„¾–ñ†¾ ˜X$]È=„kt• ©¸ÐÀÜàÂõà“áÂÂÀÂõ²û²¢ÄÔâÄÕâü€-Ò Ò©¸–Ú» »
Ãõ²û²¢Ä
Ö:l
L…

Ã
¤›4 EÅÆ§× `ÅÇ–ñ2„¾ÅÈk<HÌÅÊ·$QœØÅ˾ò\nÅÌlLmt']T;NP=?ì\.üåDíÎÏÏΧ³ê¸³ îɳܹÐÀcÐ#%(*ü°8³ÓÔÕ Óܹ Ô c cˆ¢cµ
 `£cÊ­ `àB¤GS
Õ‹µÍ ·Í
Ðõ²û²± ¾ÜØíÒÓÒÓ§³Ý¸³ áܹÔüú+ˆBõ²û²ܹÑÑ
Ôõ²û²ê?4Œ± ˜üÐdíÖ×¥Ø×ØÖÌø³ Ù´Ä ÜθÍÄä—§³ÕܹÙÚÜFGHÜÚ"$OQTVÕÕ¢ÄüÏKÖר„¾„¾–ñ†¾ ˜X$]È=„kt• Öܹ ×ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åØ·ÇÕ æÕ
Úõ²û²¢ÄûÔòÚÜàÛõàÛ“áÛÛÚÛõ²û²¢ÄÆâ û²üš-LÙ Ùܹ–ÚÕ §Õ
Üõ²û²¢Äœ˜
"@L®

ë
ñ
ÎX$í Þߪ¤›4(EÞà§–ñ@„¾Þák<VÌÞã·$_œØÞä¾ò\|Þ弄l!pt5]TINP=?ìj.´¤¥ç¦èçè×Ê © ¬›»éüÁ\ÏBˆ âª›»ææì„û„4–
鈠⪬ Ó­ ÙüœU¥ë¦ìëìÏ… ¤ì„û„´Ú×Ê ¡›»íîïFGHïî"$GIêêÀ­ü’QL•ÚÛÜ„¾„¾–ñ†¾ ˜X$]È=„kt• Ú›» ÛÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åܼñê ©ê
âªûÔµüî-Ý Ý›»–Úê ûê
âªüï ­ÞÞßàᄾ„¾–ñ†¾ ˜X$]È=„kt• Þˆ „¾„¾–ñ†¾ ˜X$]È=„kt• ß⪠àÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åá¼ñ¥ñ¦òòñ
×Ê ü  ÿ ì„
û„´… Ï… 
ðˆ âªfirstÁ,‡
secondÁ4Ÿ
ûÔ¸
UWZ\
•EDÐ

 ¥ ¤›4 Eôõ§Áì4&‚Øôö¶ñl@”íô÷¶ñ•íô÷–ñ^„¾ôøk<tÌôú·$}œØôû¾òôül¯¤œÜ2tScTgTVCEìˆ5üá!äþíÿþÿ¹ôêú»æü‰-B£õú»ýý
äÒ¥ê?4›ü98âíâ¹ô¿öÎö¨½ƒƒØ„Ø,.Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¤öüõIãä儾„¾–ñ†¾ ˜X$]È=„kt• 㨽 äÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾ååœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã¨½ƒØ 
8Ò¥ûÔ
DIDë

 Ñ ¤›4 E§× `ˆ–ñ2„¾ÿñ,H¥‚k<OÌŒ·$XœØ¾ò\uŽlL„t'tT;ceRTACìc2üç:í§³ìɳT–þÀcü¨8«æçè æþ ç c cˆ¢cµ
 `£cÊ­ `àB¤GS
苵 ¯
õ²± ŒÌí§³Ñþ 
üä7òBõ²þ
õ²ê?4öÂfL‚üÊ2í§³Ïθþ˜FGH˜*,²¸üžXéê넾„¾–ñ†¾ ˜X$]È=„kt• éþ êÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åëœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙþF ¹
˜õ²ûÔÅüŠ
-L
ì ìþ–Ú

õ²$˜
É Üàšõàš“ášššõ² þ
{NtŠ

 ÷ ¤›4 Eœ§× `œž–ñ2„¾œŸÿñ,H¥‚œ¡k<OÌœ¢·$XœØœ£¾ò\uœ¤lL„t'tT;ceRTACìc2üÿEí¦§¦§§³¸³ ˆɳò¿¨Àc¨#%(*üË8Îíîï íò¿ î c cˆ¢cµ
 `£cÊ­ `àB¤GS
¥ Ò¥
¨õ²û²± Ùäôíª«ª«§³ù¸³ ýò¿¬ü—3¥Bõ²û²ò¿©©
¬õ²û²ê?4©÷hLµü«^í®¯®¯ðû² 𲸘"$„¸³ ´θð“"û²Å’Äð§³°ò¿°±²FGH±²"$XZL$•­­²¸ü«Tñò󄾄¾–ñ†¾ ˜X$]È=„kt• ñò¿ òÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åóœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙò¿F­ ­
±õ²û²ûÔÎüÈ - ô ôò¿–Ú­ Õ ­
²õ²û² ¬¢
TDº

 £ ¤›4 E´µ§´×- `´·–ñA„¾´¸k<WÌ´º·$`œØ´»¾ò\}´¼l“LL'rt6bTJSUBDìk3üï:í¾¾§³ôɳ¡Á¿Àc¿ü°8³õö÷ õ¡Á ö c cˆ¢cµ
 `£cÊ­ `àB¤GS
÷‹µ½ ·½
¿õ²± ¾ŒÔíÁÁ§³Ù¡Á 
üì7úBõ²¡ÁÀÀ
Âõ²ê?4þÂfLŠüÒ2íÄħ³×θ¡ÁÅÆÈFGHÈÆ*,L‹$Ãò¸ü¦Xøùú„¾„¾–ñ†¾ ˜X$]È=„kt• ø¡Á ùÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åúœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¡ÁFà ÁÃ
Æõ²ûÔÍÆÜàÇõàÇ“áÇÇÆÇõ²É⃼ „¾„¾–ñ†¾ ˜X$]È=„kt• ¡Áü‚ -L… û û¡Á–Úà Ã
Èõ²$ 
qYtÙ

 Ê ¤›4 EÊ˧נ`ÊÌ–ñ2„¾ÊÍk<HÌÊÏ·$QœØÊоò\nÊÑlLmt']T;NP=?ì\.ü„EíÓÔÓÔ§³¸³ ɳÜÂÕÀcÕ#%(*üÐ8Óüýþ üÜ ý c cˆ¢cµ
 `£cÊ­ `àB¤GS
þ‹µÒ ×Ò
Õõ²û²± Þä íרØ×§³¥¸³ ©ÜÂÙüÃ3ÑBõ²û²ÜÂÖÖ
Ùõ²û²ê?4Õ÷hLáüß^íÛÜÜÛÿû² ÿ²¸˜"¸³ èθ4•ÿ“"û²ĨĤ§³äÜÂÝÞáFGHáÞ"$XZÚÚ²¸üßX„¾„¾–ñ†¾ ˜X$]È=„kt• Ü ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÜÂFÚ úÚ
Þõ²û²ûÔÞÜàßõàß“áßßÞßõ²û²Í¡ „¾„¾–ñ†¾ ˜X$]È=„kt• ÜÂÞÜààõàà“áààÞàõ²û²Ôüõ­ü‰
-
ƒ ƒÜ–ÚÚ
Ú
áõ²û²$—
–
í_D‰
$
 ü ¤›4 Eãä§× `ãåÁì45‚Øãæ–ñL„¾ãçk<bÌãé·$kœØãê¾òãëlL„¤'ttAcTUTVCEìv4ü¢Jíí¾)îïîïí§³§Íì÷Ä«Êô °ɳ­ÄðÀcð460257üó8ö ­Ä  c cˆ¢cµ
 `£cÊ­ `àB¤GS
‹µì úì
ðõ²÷ÄØ¥± ü—!íò¾)óôóòô§³œ–² Êô ¥­Äõ "%'ü¿+ÍBõ²Ø¥­Äññ
õõ²÷ÄØ¥ê?4ѱ ÝüÌrí÷ø¾)ù÷øùû²ÔØ"‘ĺ¸³ ÕÍì‘ÄØθ4‡‚Ø‘ÄÍÄ´§§³Ñ’ÅúûüFGHüû"$ikegöö‘ăØüãUˆ„¾„¾–ñ†¾ ˜X$]È=„kt• ’Å ˆÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ€¸ö úö
ûõ²û²‘ÄûÔü¢-Š Š’Å–Úö ¯ö
üõ²û²‘ÄüÜàýõàý“áýýüýõ²û²‘ÄÅŒšÚ™‚T›
rfd¨


·
ªc$œ ÿ¤›4(Eÿ§Áì4C‚Øÿ¶ñl]”íÿƒ¶ñ•íÿƒ–ñ{„¾ÿk<‘Ìÿ·œØÿ¾òÿˆ¼Êl!¶¤5£ÜOtpjT„\^JLì¥;ü‘$äŠíйôšëÅŒü¼-ÊB£õëÅ
ŒäÒ¥ê?4ÎüÕW8¥ŽíŽØÇFÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ˆªô°œô¦ ÝÎìØÇàEØÇÜíÚ Ú“íØÇ,‹™ÇƒØ„Ø-/bd^`4¸Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙˆªô°üÜIŒŽ„¾„¾–ñ†¾ ˜X$]È=„kt• Œ™Ç ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åŽœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã™ÇƒØ î
8ˆªô°ØÇûÔúŒº
bkdÎ


ã
–ñ„¾k<#Ì·$,œØ˜¤›4FE¾ò\dšÎX$‰í ªÈ,Lš¨œÙl™LŠŒy{¤8jìR[¼vL„“9Üú¥žž×Ê ÿì„4‚¶ÈŸ üœ$ªˆ ¶È
Ÿˆ ê?4®üÃLü–(% Peek at the next item in the stream.Á$Ð ¶Èˆ ¡ Փ툠,‰
 ˆ {y€Éã 8ÉÉ ¢ˆ ÂãÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ 8À­ 8¶ÈÍ술8¡©‚ØÀ̸À̃ØÝËʸÌÐÓÌÖâÌÜ #q <coroutine_kind>Á¢ <resume_ty>Á¢
<yield_ty>Á¢ <return_ty>Á¢“ᢢ µãüÃ&¥¤¤×Ê Èì„¶È¥¦FG¦ "££À­üŠTL„¾„¾–ñ†¾ ˜X$]È=„kt• ¶È ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¶ÈF£ ¡£
¦ˆ $—ûÔ­”ä
ëpÜ–
üÁJ
G An extension trait for the [`Stream`] trait that provides a variety ofÁüŒ $
! convenient combinator functions.Á±
úüµ O
L Be aware that the `Stream` trait in Tokio is a re-export of the trait foundÁü…
K
H in the [futures] crate, however both Tokio and futures provide separate矄
O
L `StreamExt` utility traits, and some utilities are only available on one ofÁü¡ N
K these traits. Click [here][futures-StreamExt] to see the other `StreamExt`Áüð 
 trait in the futures crate.Á
úü” L
I If you need utilities from both `StreamExt` traits, you should prefer toÁüá J
G import one of them, and use the other through the fully qualified callÁĬ
 syntax. For example:Á
Ï¥üÍ
 // import one of the traits:Áüî
#
use futures::stream::StreamExt;Áü’/
«£¼Â
ã£Ú
úüÞ.
+ let a = tokio_stream::iter(vec![1, 3, 5]);Áü.
+ let b = tokio_stream::iter(vec![2, 4, 6]);Á¼
úüÀ?
< // use the fully qualified call syntax for the other trait:Áü€6
3 let merged = tokio_stream::StreamExt::merge(a, b);Á·
úü»G
D // use normal call notation for futures::stream::StreamExt::collectÁüƒ0
- let output: Vec<_> = merged.collect().await;Áü´/
, assert_eq!(output, vec![1, 2, 3, 4, 5, 6]);Á
¿¥
Ï¥ô
úìø
 [`Stream`]: crate::StreamÁü–&
# [futures]: https://docs.rs/futuresÁü½X
U [futures-StreamExt]: https://docs.rs/futures/0.3/futures/stream/trait.StreamExt.htmlÁL 
¨¨³ü–³«
E»
¨³*”ß³6”ߪ­°³¸º½¾¿ÁÂÄÆÈÊÍÏÐÑÒÓ©ª­°³¸º½¾¿ÁÂÄÆÈÊÍÏÐÑÒÓ°ÆÑ³¾ÁÄÏÒ©¿ÊÂͺнÈÓª¸­üÆC
ü¸F
C Consumes and returns the next value in the stream or `None` if theÁ¼ƒ
 stream is finished.ÁŸ
ú”§
 Equivalent to:Á¾
ú
```ignore矯3
0 async fn next(&mut self) -> Option<Self::Item>;Á<
Ï¥œ
úü¤D
A Note that because `next` doesn't take ownership over the stream,ÁüíK
H the [`Stream`] type must be [`Unpin`]. If you want to use `next` with aÁü½K
H [`!Unpin`](Unpin) stream, you'll first have to pin the stream. This canÁü6
3 be done by boxing the stream using [`Box::pin`] orÁüÈK
H pinning it to the stack using the `pin_mut!` macro from the `pin_utils`ÁT˜
 crate.Á§
úœ¯
 # Cancel safetyÁÇ
úüÏ8
5 This method is cancel safe. The returned future onlyÁüŒ4
1 holds onto a reference to the underlying stream,矁+
( so dropping it will never lose a value.Áõ
ú
# ExamplesÁ
ú<˜
Ï¥ü¤/
«£¼Ø
ã£üô2
㢫
úü³)
& let mut stream = stream::iter(1..=3);Áá
úüé-
* assert_eq!(stream.next().await, Some(1));Áü›-
* assert_eq!(stream.next().await, Some(2));ÁüÍ-
* assert_eq!(stream.next().await, Some(3));Áüÿ*
' assert_eq!(stream.next().await, None);Á
¿¥
Ï¥
 »œ œ ªcŸ ê?ô  €@ô³\~PL­œW»¨ Î
¨“í»
©»
üó'n
ü³D
A Consumes and returns the next item in the stream. If an error isÁüüD
A encountered before the next item, the error is returned instead.ÁÅ
ú”Í
¥áä
ú
Ìáüþ9
6 async fn try_next(&mut self) -> Result<Option<T>, E>;Á
Ï¥È
úüÐ @
= This is similar to the [`next`](StreamExt::next) combinator,Áü•!>
; but returns a [`Result<Option<T>, E>`](Result) rather than矯!<
9 an [`Option<Result<T, E>>`](Option), making for easy useÁü™"+
( with the [`?`](std::ops::Try) operator.ÁÉ"
úœÑ"
äåé"
úüñ"8
æü®#4
Ïæüç#+
ç—$
útŸ$
Íç²$
ú<º$
Ï¥üÆ$/
«£¼ú$
ã£%
úüž%2
ã¢Õ%
úüÝ%C
@ let mut stream = stream::iter(vec![Ok(1), Ok(2), Err("nope")]);Á¥&
úü­&5
2 assert_eq!(stream.try_next().await, Ok(Some(1)));Áüç&5
2 assert_eq!(stream.try_next().await, Ok(Some(2)));Áü¡'5
2 assert_eq!(stream.try_next().await, Err("nope"));Á<Û'
¿¥<ç'
Ï¥Dö'
 »®
®
§t±
ÿ;ÿ²
€@ÿÃξÓU¤i»¨¥«¬«¬ …(
¨Ú ÿ'
¦ (
”ßܽ(
»F’ÁœÄ(
ãì,Û(
ª»ˆªô°$Š(
FHKMüË0j
üŽ)K
H Maps this stream's items to a different type, returning a new stream ofÁ¼Þ)
 the resulting type.Áú)
úü‚*H
E The provided closure is executed over all elements of this stream asÁüÏ*@
= they are made available. It is executed inline with calls toÁü”+%
" [`poll_next`](Stream::poll_next).Á¾+
úüÆ+L
I Note that this function consumes the stream passed into it and returns aÁü—,G
D wrapped version of it, similar to the existing `map` methods in theÁ¬ã,
 standard library.Áý,
út…-
Íç˜-
ú< -
Ï¥ü¬-/
«£¼à-
ã£üü-2
㢳.
úü».%
" let stream = stream::iter(1..=3);Áüå.+
( let mut stream = stream.map(|x| x + 3);Á•/
úü/-
* assert_eq!(stream.next().await, Some(4));ÁüÏ/-
* assert_eq!(stream.next().await, Some(5));Áü0-
* assert_eq!(stream.next().await, Some(6));Á<³0
¿¥<¿0
Ï¥Î0
»Ø¥

âZ
ê?«
±«Nç
z8³»Ø¥¨¥®¯®¯¨Ú Ò0
Êô Õ0
“"Ø¥»F´‰1
Ø¥¤€˜"ˆª ž1
Íì»,¯1
­»ˆªØ¥$Ø0
± Þ0
pruwü¤<}
üá1L
I Map this stream's items to a different type for as long as determined byÁü²2G
D the provided closure. A stream of the target type will be returned,Áüþ2?
< which will yield elements until the closure returns `None`.ÁÂ3
úüÊ3H
Î÷ü—4K
H they are made available, until it returns `None`. It is executed inlineÁüç4L
I with calls to [`poll_next`](Stream::poll_next). Once `None` is returned,Áü¸53
0 the underlying stream will not be polled again.Áð5
úüø5L
¥ùüÉ6O
L wrapped version of it, similar to the [`Iterator::map_while`] method in theÁ¬7
Ëú·7
út¿7
ÍçÒ7
ú<Ú7
Ï¥üæ7/
«£¼š8
ã£ü¶82
ã¢í8
úüõ8&
# let stream = stream::iter(1..=10);Áü 9+
( let mut stream = stream.map_while(|x| {Á”Ð9
 if x < 4 {Á¼ç9
 Some(x + 3)Á„ƒ:
} else {Á„˜:
NoneÁL­:
<»:
 });矂:-
Áüüù:-
øüü«;-
¯ýüÝ;*
—ê<Œ<
¿¥<˜<
Ï¥L§<
»Ø¥¾
¾
À]Á
ê?ÅÂ
±Å›}­?ÜŸé»Ø¥¨¥±²±²¨Ú ±<
Êô ´<
™€ôí<
Ø¥¤€˜"ÐÃL‚=
Ì€,=
°»ˆªØ¥$·<
± ½<
SUXZü£HŠ
üÒ=L
I Maps this stream's items asynchronously to a different type, returning a矣>%
" new stream of the resulting type.ÁÍ>
úüÕ>H
Î÷ü¢?J
G they are made available, and the returned future is executed. Only oneÁüñ?#
future is executed at the time.Á™@
úü¡@L
¥ùüò@H
E wrapped version of it, similar to the existing `then` methods in theÁ¬¿A
ËúÙA
úüáAL
I Be aware that if the future is not `Unpin`, then neither is the `Stream`Áü²BL
I returned by this method. To handle this, you can use `tokio::pin!` as inÁüƒCK
H the example below or put the stream in a `Box` with `Box::pin(stream)`.ÁÓC
útÛC
ÍçîC
ú<öC
Ï¥ü‚D/
«£¼¶D
ã£üÒD2
㢉E
úü‘E/
, async fn do_async_work(value: i32) -> i32 {ÁŒÅE
 value + 3Á,ÛE
±¥åE
úüíE%
Ñûü—F,
) let stream = stream.then(do_async_work);ÁÈF
úÄÐF
 tokio::pin!(stream);ÁíF
úüõF-
Áüü§G-
øüüÙG-
¯ý<H
¿¥<—H
Ï¥$¦H
»û²õ õ âpù ê?ãú Žqãû ±ãMC‚*xE¸ž»‘Äû²¨´¾)µµ´¨¸³ «H
ë¶®H
“"û²¤€ÄêH
û²¤€˜"‘ÄÿH
„·4I
Ì€,§I
³»û²‘Ä$³H
± ¹H
gilnü´ar
üÚII
F Combine two streams into one by interleaving the output of both as itÁ„¨J
is produced.Á½J
úüÅJL
I Values are produced from the merged stream in the order they arrive fromÁü–KA
> the two source streams. If both source streams provide values矆KK
H simultaneously, the merge stream alternates between them. This providesÁü¬LJ
G some level of fairness. You should not chain calls to `merge`, as thisÁüûL+
( will break the fairness of the merging.Á«M
úü³MK
H The merged stream completes once **both** source streams complete. WhenÁüƒNB
? one source stream completes before the other, the merge streamÁüÊN+
( exclusively polls the remaining stream.ÁúN
úü‚OG
D For merging multiple streams, consider using [`StreamMap`] instead.ÁÎO
úüÖO#
[`StreamMap`]: crate::StreamMapÁþO
út†P
ꍪP
ú<¡P
Ï¥ü­P*
' use tokio_stream::{StreamExt, Stream};ÁÔÜP
 use tokio::sync::mpsc;Á¤ûP
 use tokio::time;Á”Q
úäœQ
 use std::time::Duration;Á´½Q
 use std::pin::Pin;ÁØQ
úDàQ
 # /*Á”íQ
 #[tokio::main]ÁD„R
 # */Áü‘R/
ǣR
 async fn main() {Á¤ßR
 # time::pause();ÁüøR8
5 let (tx1, mut rx1) = mpsc::channel::<usize>(10);ÁüµS8
5 let (tx2, mut rx2) = mpsc::channel::<usize>(10);ÁòS
úüúS.
+ // Convert the channels to a `Stream`.Áü­T2
/ let rx1 = Box::pin(async_stream::stream! {ÁüäT7
4 while let Some(item) = rx1.recv().await {Áì U
 yield item;Á|ÂU
üÖU8
5 }) as Pin<Box<dyn Stream<Item = usize> + Send>>;Á“V
úü›V2
/ let rx2 = Box::pin(async_stream::stream! {ÁüÒV7
4 while let Some(item) = rx2.recv().await {ÁìŽW
ñ¡|°W
—¢üÄW8
°¢X
úü‰X$
! let mut rx = rx1.merge(rx2);Á²X
úüºX!
 tokio::spawn(async move {ÁüàX+
( // Send some values immediatelyÁüY'
$ tx1.send(1).await.unwrap();Áü¼Y'
$ tx1.send(2).await.unwrap();ÁèY
úüðY-
* // Let the other task send values矢Z9
6 time::sleep(Duration::from_millis(20)).await;ÁàZ
úüèZ'
$ tx1.send(4).await.unwrap();Á\”[
 });Á¤[
úü¬[!
é¤üÒ[5
2 // Wait for the first task to send valuesÁüŒ\8
5 time::sleep(Duration::from_millis(5)).await;ÁÉ\
úüÑ\'
$ tx2.send(3).await.unwrap();Áý\
úü…]9
6 time::sleep(Duration::from_millis(25)).await;ÁÃ]
úüË]#
// Send the final valueÁüó]'
$ tx2.send(5).await.unwrap();Á\Ÿ^
í§¯^
úü·^/
, assert_eq!(1, rx.next().await.unwrap());Áüë^/
, assert_eq!(2, rx.next().await.unwrap());ÁüŸ_/
, assert_eq!(3, rx.next().await.unwrap());ÁüÓ_/
, assert_eq!(4, rx.next().await.unwrap());Áü‡`/
, assert_eq!(5, rx.next().await.unwrap());Á»`
úüÃ`'
$ // The merged stream is consumedÁüï`*
' assert!(rx.next().await.is_none());Á,ža
±¥<¨a
Ï¥,·a
»âªë
ë
£`î
¬Þï
­Þð
Ð`Þ+Í½ŠŽ(,ػ⪨¦··¨ ½a
û„Ì÷a
âªF¦€Œþa
Ì€, b
»âª$Àa
¹
,Æa
BDüökq
üØbH
E Filters the values produced by this stream according to the providedÁt¥c
predicate.Á¸c
úüÀcK
H As values of this stream are made available, the provided predicate `f`Áüd.
+ will be run against them. If the predicateÁüÃdH
E resolves to `true`, then the stream will yield the value, but if theÁüe1
. predicate resolves to `false`, then the value矮e:
7 will be discarded and the next value will be produced.Á…f
úüfL
¥ùüÞfH
E wrapped version of it, similar to [`Iterator::filter`] method in theÁ¬«g
ËúÅg
útÍg
Íçàg
ú<èg
Ï¥üôg/
«£¼¨h
ã£üÄh2
ã¢ûh
úüƒi%
" let stream = stream::iter(1..=8);Áü­i2
/ let mut evens = stream.filter(|x| x % 2 == 0);Áäi
úüìi,
) assert_eq!(Some(2), evens.next().await);Áüj,
) assert_eq!(Some(4), evens.next().await);ÁüÎj,
) assert_eq!(Some(6), evens.next().await);Áüÿj,
) assert_eq!(Some(8), evens.next().await);Áü°k)
& assert_eq!(None, evens.next().await);Á<Þk
¿¥<êk
Ï¥4ùk
»û²ÑÑüNÔê?ÓÕ±Ó‹è»û²¨¹¹¨¸³ €l
“"û² ¦€Ô·l
û²›»˜"$Íl
Ì€,ál
¸»û²$ƒl
± ‰l
giü÷v
ü–mK
H Filters the values produced by this stream while simultaneously mappingÁüæm?
< them to a different type according to the provided closure.Áªn
úü²nK
H As values of this stream are made available, the provided function willÁü‚o4
1 be run on them. If the predicate `f` resolves toÁü»oL
I [`Some(item)`](Some) then the stream will yield the value `item`, but ifÁüŒp<
9 it resolves to [`None`], then the value will be skipped.ÁÍp
úüÕpL
¥ùü¦qL
I wrapped version of it, similar to [`Iterator::filter_map`] method in theÁ¬÷q
Ëúr
út™r
Íç<¬r
Ï¥ü¸r/
«£¼ìr
ã£üˆs2
㢿s
úüÇs%
îµüñs+
( let mut evens = stream.filter_map(|x| {Áü¡t3
0 if x % 2 == 0 { Some(x + 1) } else { None }Á<Ùt
â‡åt
úüít,
) assert_eq!(Some(3), evens.next().await);Áüžu,
) assert_eq!(Some(5), evens.next().await);ÁüÏu,
) assert_eq!(Some(7), evens.next().await);Áü€v,
) assert_eq!(Some(9), evens.next().await);Áü±v)
½¸<ßv
¿¥<ëv
Ï¥Túv
»Ø¥þþÝQ ê?ë±ëï±ÞÉu^ƒr»Ø¥¨¥»¼¼»¨Ú …w
Êô ˆw
™€ôÂw
æŠL×w
Ì€,ðw
º»ˆªØ¥$‹w
± w
DFIKü¢ˆ:
ü¨x7
4 Creates a stream which ends after the first `None`.Áäx
úüìxI
F After a stream returns `None`, behavior is undefined. Future calls to矼yH
E `poll_next` may or may not return `Some(T)` again or they may panic.Áü‡zJ
G `fuse()` adapts a stream, ensuring that after `None` is given, it willÁÔÖz
 return `None` forever.Áõz
útýz
Íç{
ú<˜{
Ï¥ü¤{*
' use tokio_stream::{Stream, StreamExt};ÁÓ{
ú´Û{
ûüö{#
use std::task::{Context, Poll};Áž|
úü¦|6
3 // a stream which alternates between Some and NoneÁ´á|
 struct Alternate {Áœü|
 state: i32,Á,”}
±¥ž}
úü¦}
 impl Stream for Alternate {ÁÄÊ}
 type Item = i32;Áç}
úüï}\
Y fn poll_next(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<i32>> {ÁüÐ~!
 let val = self.state;Áüö~(
% self.state = self.state + 1;Á£
úü«1
. // if it's even, Some(i32), else NoneÁìá
 if val % 2 == 0 {Áüƒ€&
# Poll::Ready(Some(val))Á¤®€
 } else {ÁüÇ€!
 Poll::Ready(None)Álí€
Lÿ€
Ї,
±¥
ú
¦ž”¬
·ž
ÒžüÐ/
«£¬„‚
ñžüž‚0
- let mut stream = Alternate { state: 0 };ÁÓ‚
úüÛ‚)
& // the stream goes back and forthÁü‰ƒ1
. assert_eq!(stream.next().await, Some(0));Áü¿ƒ.
+ assert_eq!(stream.next().await, None);Áüòƒ1
. assert_eq!(stream.next().await, Some(2));Áü¨„.
ÅÑÛ„
úüã„$
! // however, once it is fusedÁüŒ…'
$ let mut stream = stream.fuse();Á¸…
úüÀ…1
. assert_eq!(stream.next().await, Some(4));Áüö….
ÅÑ©†
úü±†=
: // it will always return `None` after the first time.Áüó†.
ÅÑü¦‡.
ÅÑüÙ‡.
ÅÑ,Œˆ
±¥<–ˆ
Ï¥$¥ˆ
»í í ÎXï ê?šéË}š–g»¨¨Ì€,Öˆ
½»$ªˆ
üªŽD
ü†‰G
D Creates a new stream of at most `n` items of the underlying stream.ÁÒ‰
úüÚ‰I
F Once `n` items have been yielded from this stream then it will alwaysÁü¨Š#
return that the stream is done.ÁЊ
útØŠ
ÍçëŠ
ú<óŠ
Ï¥üÿŠ/
«£¼³‹
ã£üÏ‹2
㢆Œ
úüŽŒ2
/ let mut stream = stream::iter(1..=10).take(3);ÁÅŒ
úüÍŒ-
* assert_eq!(Some(1), stream.next().await);ÁüÿŒ-
* assert_eq!(Some(2), stream.next().await);Áü±-
* assert_eq!(Some(3), stream.next().await);Áüã*
' assert_eq!(None, stream.next().await);Á<’Ž
¿¥<žŽ
Ï¥$­Ž
»Ÿ Ÿ »k¡ ê?´¢ Âf´Ð;¹dÌ-^Í»¨¨Ì€,èŽ
¾»$²Ž
¹ ¸Ž
üÏ•x
ü›?
< Take elements from this stream while the provided predicateÁ¼ß
 resolves to `true`.Áû
úüƒK
H This function, like `Iterator::take_while`, will take elements from theÁüÓH
E stream until the predicate `f` resolves to `false`. Once one elementÁü @
= returns false it will always return that the stream is done.Áå‘
útí‘
Í瀒
ú<ˆ’
Ï¥ü”’/
«£¼È’
ã£üä’2
㢛“
úü£“B
? let mut stream = stream::iter(1..=10).take_while(|x| *x <= 3);Áê“
úüò“-
ÈÙü¤”-
€ÚüÖ”-
¸Úüˆ•*
ðÚ<·•
¿¥<Õ
Ï¥TÒ•
»û²Ä Ä ÚmÇ ê?ÊÈ ÷hÊÉ ‹nÊ„uÞDÚMF»û²¨ÀÀ¨¸³ Ý•
“"û² ¦€Ô—–
û²„ä˜"
Ì€,Á–
¿»û²$à•
± æ•
moü¶›D
üù–B
? Creates a new stream that will skip the `n` first items of theÁ´À—
 underlying stream.ÁÛ—
útã—
Íçö—
ú<þ—
Ï¥üŠ˜/
«£¼¾˜
ã£üÚ˜2
㢑™
úü™™2
/ let mut stream = stream::iter(1..=10).skip(7);ÁЙ
úüØ™-
* assert_eq!(Some(8), stream.next().await);ÁüŠš-
* assert_eq!(Some(9), stream.next().await);Áü¼š.
+ assert_eq!(Some(10), stream.next().await);Áüïš*
ðÚ<ž›
¿¥<ª›
Ï¥$¹›
»Í Í ¦fÏ ê?Ð Âfʲ~ŸÚ†Ù»¨¨Ì€,ô›
Á»$¾›
¹ Ä›
ü±£x
ü§œI
F Skip elements from the underlying stream while the provided predicateÁ¼õœ
¢Ý
úü™O
L This function, like [`Iterator::skip_while`], will ignore elements from theÁüíH
§Þüºž<
9 returns false, the rest of the elements will be yielded.Áûž
úüƒŸ?
< [`Iterator::skip_while`]: std::iter::Iterator::skip_while()ÁÇŸ
útÏŸ
ÍçâŸ
ú<êŸ
Ï¥üöŸ/
«£¼ª 
ã£üÆ 2
ã¢üý J
G let mut stream = stream::iter(vec![1,2,3,4,1]).skip_while(|x| *x < 3);ÁÌ¡
úüÔ¡-
¸Úü†¢-
* assert_eq!(Some(4), stream.next().await);Áü¸¢-
ÈÙüê¢*
ðÚ<™£
¿¥<¥£
Ï¥T´£
»û²ò ò Îhõ ê?œö ÷hœ¶bÖå)•¢ß»û²¨Ã踳 ¿£
“"û² ¦€Ôù£
û²Ùð˜"$¤
Ì€,£¤
»û²$£
± È£
moü¥±y
üÛ¤=
: Tests if every element of the stream matches a predicate.Á¥
ú”¥¥
¥á¼¥
úlÄ¥
ÌáüÖ¥-
* async fn all<F>(&mut self, f: F) -> bool;Á<ˆ¦
Ï¥”¦
úüœ¦F
C `all()` takes a closure that returns `true` or `false`. It appliesÁüç¦F
C this closure to each element of the stream, and if they all returnÁü²§A
> `true`, then so does `all`. If any of them return `false`, itÁüø§4
1 returns `false`. An empty stream returns `true`.籬
úü¹¨H
E `all()` is short-circuiting; in other words, it will stop processingÁü†©J
G as soon as it finds a `false`, given that no matter what else happens,ÁüÕ©$
! the result will also be `false`.Áþ©
úü†ª#
An empty stream returns `true`.稻
út¶ª
Íçɪ
ú„Ѫ
Basic usage:羻
ú<îª
Ï¥üúª/
«£¼®«
ã£üÊ«2
㢬
ú´‰¬
 let a = [1, 2, 3];Á¤¬
úü¬¬4
1 assert!(stream::iter(&a).all(|&x| x > 0).await);Áå¬
úüí¬5
2 assert!(!stream::iter(&a).all(|&x| x > 2).await);Á<§­
¿¥<³­
Ï¥¿­
úüÇ­"
 Stopping at the first `false`:Áî­
ú<ö­
Ï¥ü‚®/
«£¼¶®
ã£üÒ®2
㢉¯
ú´‘¯
ø¬¯
úü´¯$
! let mut iter = stream::iter(&a);Áݯ
úüå¯*
' assert!(!iter.all(|&x| x != 2).await);Á”°
úüœ°;
8 // we can still use `iter`, as there are more elements.Áüܰ,
) assert_eq!(iter.next().await, Some(&3));Á<±
¿¥<™±
Ï¥¨±
˜ ˜»û²ææÁ?êê?Eë±Eì€@Ev+b œÝX˜»û²¨ÅÅ ¯±
¨¸³ ¬±
ãì,ò±
²•Ì„²
û²¤€˜"$™²
Ä»û²$´±
± º±
KMüܾy
üв;
8 Tests if any element of the stream matches a predicate.Á³
ú”˜³
¥á¯³
úl·³
Ìáüɳ-
* async fn any<F>(&mut self, f: F) -> bool;Á<û³
Ï¥‡´
úü´F
C `any()` takes a closure that returns `true` or `false`. It appliesÁüÚ´I
F this closure to each element of the stream, and if any of them returnÁü¨µ@
= `true`, then so does `any()`. If they all return `false`, itÁ¤íµ
 returns `false`.砦
úü޶H
E `any()` is short-circuiting; in other words, it will stop processingÁüÛ¶I
F as soon as it finds a `true`, given that no matter what else happens,Áü©·#
the result will also be `true`.ÁÑ·
úüÙ·$
! An empty stream returns `false`.Á‚¸
ú„Џ
“÷Ÿ¸
ú<§¸
Ï¥ü³¸/
«£¼ç¸
ã£üƒ¹2
㢺¹
ú´Â¹
øݹ
úüå¹4
1 assert!(stream::iter(&a).any(|&x| x > 0).await);Ážº
úü¦º5
2 assert!(!stream::iter(&a).any(|&x| x > 5).await);Á<àº
¿¥<ìº
Ï¥øº
úü€»!
 Stopping at the first `true`:Á¦»
ú<®»
Ï¥üº»/
«£¼î»
ã£üм2
ã¢Á¼
ú´É¼
øä¼
úüì¼$
€û•½
úü½)
& assert!(iter.any(|&x| x != 2).await);Á˽
úüÓ½;
þûü“¾,
) assert_eq!(iter.next().await, Some(&2));Á<ľ
¿¥<о
ϥ߾
 »û²¤¤ŸD¨ê?Z©±Zª€@Zqý¢e|ÿ‡
»û²¨ÇÇ æ¾
¨¸³ ã¾
ãì,©¿
²•Ì»¿
Ñÿ$п
Æ»û²$ë¾
± ñ¾
>@üØÇr
ü‡ÀG
D Combine two streams into one by first returning all values from theÁüÓÀ8
5 first stream then all values from the second stream.ÁÁ
úü˜ÁJ
G As long as `self` still has values to emit, no values from `other` areÁüçÁ$
! emitted, even if some are ready.ÁÂ
út˜Â
Íç«Â
ú<³Â
Ï¥ü¿Â2
ã¢öÂ
úüþÂ/
«£¼²Ã
ã£üÎÃ*
' let one = stream::iter(vec![1, 2, 3]);ÁüýÃ*
' let two = stream::iter(vec![4, 5, 6]);Á¬Ä
úü´Ä$
! let mut stream = one.chain(two);ÁÝÄ
úüåÄ-
òèü—Å-
©éüÉÅ-
àéüûÅ-
Áüü­Æ-
øüü߯-
¯ýü‘Ç*
—ê<ÀÇ
¿¥<ÌÇ
Ï¥,ÛÇ
»âªââ…Hå¬oæ­o ldŒ—»âª¨¦Éɨ áÇ
û„Ì›È
é°Œ¢È
Ì€,ÄÈ
È»âª$äÇ
¹
,êÇ
>@üÎÍ
üüÈE
B A combinator that applies a function to every element in a streamÁüÆÉ$
! producing a single, final value.畃
ú”÷É
¥áŽÊ
úl–Ê
Ìáü¨Ê2
/ async fn fold<B, F>(self, init: B, f: F) -> B;Á<ßÊ
Ï¥ëÊ
útóÊ
Í焆Ë
“÷<›Ë
Ï¥ü§Ë/
«£¼ÛË
ã£ü÷Ë*
' use tokio_stream::{self as stream, *};Á¦Ì
úü®Ì*
' let s = stream::iter(vec![1u8, 2, 3]);ÁüÝÌ0
- let sum = s.fold(0, |acc, x| acc + x).await;Á’Í
ú¼šÍ
 assert_eq!(sum, 6);Á<¶Í
¿¥<ÂÍ
Ï¥$ÑÍ
»¦µØ¥« « ÁT¯ ê?° óT± ±² €@bìMŒ‡žÛ»¦µØ¥¨ËÌÌ˨æË ÖÍ
Êô ÙÍ
Ì€,£Î
“"Ø¥¦µ¦€̵Î
Ø¥ùš˜"¦µ ÍÎ
Ê»¦µØ¥$ÜÍ
‡Ì$âÍ
± ëÍ
uwy{üåà
üˆÏ>
; Drain stream pushing all emitted values into a collection.ÁËÏ
ú”ÓÏ
¥áêÏ
úlòÏ
Ìáü„Ð#
async fn collect<T>(self) -> T;Á<¬Ð
Ï¥¸Ð
úüÀÐL
I `collect` streams all values, awaiting as needed. Values are pushed intoÁü‘ÑC
@ a collection. A number of different target collection types areÁüÙÑ<
9 supported, including [`Vec`], [`String`], and [`Bytes`].ÁšÒ
úü¢ÒB
? [`Bytes`]: https://docs.rs/bytes/0.6.0/bytes/struct.Bytes.htmlÁéÒ
útñÒ
# `Result`Á„Ó
úüŒÓJ
G `collect()` can also be used with streams of type `Result<T, E>` whereÁüÛÓH
E `T: FromStream<_>`. In this case, `collect()` will stream as long asÁü¨ÔK
H values yielded from the stream are `Ok(_)`. If `Err(_)` is encountered,ÁüøÔ>
; streaming is terminated and `collect()` returns the `Err`.Á»Õ
ú\ÃÕ
 # NotesÁÓÕ
úüÛÕF
C `FromStream` is currently a sealed trait. Stabilization is pendingÁü¦Ö&
áŽÑÖ
útÙÖ
ÍçìÖ
ú„ôÖ
“÷‰×
ú<‘×
Ï¥ü×2
ã¢Ô×
úüÜ×/
«£¼Ø
ã£ܬØ
 let doubled: Vec<i32> =ÁüÌØ#
stream::iter(vec![1, 2, 3])ÁÜôØ
 .map(|x| x * 2)Á´”Ù
 .collect()Áœ¯Ù
 .await;ÁÇÙ
úüÏÙ'
$ assert_eq!(vec![2, 4, 6], doubled);Á<ûÙ
¿¥<‡Ú
Ï¥“Ú
úü›Ú*
' Collecting a stream of `Result` valuesÁÊÚ
ú<ÒÚ
Ï¥üÞÚ2
㢕Û
úüÛ/
«£¼ÑÛ
ã£üíÛ=
: // A stream containing only `Ok` values will be collectedÁü¯Ü(
% let values: Result<Vec<i32>, &str> =ÁüÜÜ/
, stream::iter(vec![Ok(1), Ok(2), Ok(3)])Á´Ý
¥œ«Ý
¯¥ÃÝ
úüËÝ*
' assert_eq!(Ok(vec![1, 2, 3]), values);ÁúÝ
úü‚ÞD
A // A stream containing `Err` values will return the first error.ÁüËÞD
A let results = vec![Ok(1), Err("no"), Ok(2), Ok(3), Err("nein")];Á”ß
úüœß(
†¨ìÉß
 stream::iter(results)Á´ëß
¥œ†à
¯¥žà
úü¦à"
 assert_eq!(Err("no"), values);Á<Íà
¿¥<Ùà
Ï¥<èà
»äJê?“K¥K€@aÕ'‡£¿»ˆªˆª¦€Ê¨¥ÎÎ¨Ú ðà
ˆª¦€´¹á
Ì€,ßá
Í»ˆª$óà
8:üÆþT
ü’â4
1 Applies a per-item timeout to the passed stream.ÁËâ
úüÓâH
E `timeout()` takes a `Duration` that represents the maximum amount ofÁü ãF
C time each element of the stream has to complete before timing out.Áëã
úüóãL
I If the wrapped stream yields a value before the deadline is reached, theÁüÄäM
J value is returned. Otherwise, an error is returned. The caller may decideÁü–åL
I to continue consuming the stream and will eventually get the next sourceÁüçå/
, stream value once it becomes available. SeeÁü›æJ
G [`timeout_repeating`](StreamExt::timeout_repeating) for an alternativeÁüêæ#
where the timeouts will repeat.Á’ç
ú\šç
‹¢ªç
úü²çB
? This function consumes the stream passed into it and returns aÁÔùç
 wrapped version of it.Á˜è
úü èK
H Polling the returned stream will continue to poll the inner stream evenÁüðè"
 if one or more items time out.Á—é
útŸé
Íç²é
úüºéJ
G Suppose we have a stream `int_stream` that yields 3 numbers (1, 2, 3):Á‰ê
ú<‘ê
Ï¥üê/
«£¼Ñê
ã£üíê2
ã¢ä¤ë
ÖüÅë+
( # let int_stream = stream::iter(1..=3);Áõë
úüýë@
= let int_stream = int_stream.timeout(Duration::from_secs(1));ÁäÂì
 tokio::pin!(int_stream);Áãì
úüëìC
@ // When no items time out, we get the 3 elements in succession:Áü³í9
6 assert_eq!(int_stream.try_next().await, Ok(Some(1)));Áüñí9
6 assert_eq!(int_stream.try_next().await, Ok(Some(2)));Áü¯î9
6 assert_eq!(int_stream.try_next().await, Ok(Some(3)));Áüíî6
3 assert_eq!(int_stream.try_next().await, Ok(None));笕
úü°ïU
R // If the second item times out, we get an error and continue polling the stream:ÁüŠðL
I # let mut int_stream = stream::iter(vec![Ok(1), Err(()), Ok(2), Ok(3)]);ÁüÛð9
ò¹ü™ñ2
/ assert!(int_stream.try_next().await.is_err());ÁüÐñ9
¶ºüŽò9
úºüÌò6
¾»‡ó
úüóG
D // If we want to stop consuming the source stream the first time anÁüÛó?
< // element times out, we can use the `take_while` operator:ÁüŸôH
E # let int_stream = stream::iter(vec![Ok(1), Err(()), Ok(2), Ok(3)]);Áüìô>
; let mut int_stream = int_stream.take_while(Result::is_ok);Á¯õ
úü·õ9
ò¹üõõ6
¾»<°ö
¿¥<¼ö
Ï¥Èö
úüÐöH
E Once a timeout error is received, no further events will be receivedÁü÷F
C unless the wrapped stream yields a value (timeouts do not repeat).Áè÷
ú<ð÷
Ï¥üü÷D
A # #[tokio::main(flavor = "current_thread", start_paused = true)]Á¼Åø
ã£üáø<
9 use tokio_stream::{StreamExt, wrappers::IntervalStream};Áä¢ù
ÖüÃùa
^ let interval_stream = IntervalStream::new(tokio::time::interval(Duration::from_millis(100)));Áü©úL
I let timeout_stream = interval_stream.timeout(Duration::from_millis(10));Áüúú
 tokio::pin!(timeout_stream);ÁŸû
úü§ûM
J // Only one timeout will be received between values in the source stream.Áüùû5
2 assert!(timeout_stream.try_next().await.is_ok());Áü³üN
K assert!(timeout_stream.try_next().await.is_err(), "expected one timeout");Áü†ýR
O assert!(timeout_stream.try_next().await.is_ok(), "expected no more timeouts");Á<Ýý
¿¥<éý
Ï¥»Å¿„ûý
Äõý
<Éþ
»­Ö­Ö„ð®ÖsecsÁâ}¯ÖnanosÁâ}Zµ–²ªÝÝÈŽßê?àÚ…áê…âùŽ Û…ì^e¦»¨¨Ì€,”ÿ
Ï»$Ñþ
ê…D×þ
üÇžg
üÑÿ4
¨®Š€
úü’€K
H `timeout_repeating()` takes an [`Interval`] that controls the time eachÁüâ€<
9 element of the stream has to complete before timing out.Á£
úü«L
¥°üüM
ü°ü΂L
Ô±üŸƒK
H stream value once it becomes available. Unlike `timeout()`, if no valueÁüïƒK
H becomes available before the deadline is reached, additional errors areÁü¿„K
H returned at the specified interval. See [`timeout`](StreamExt::timeout)Áü8
5 for an alternative where the timeouts do not repeat.ÁÌ…
ú\Ô…
‹¢ä…
úüì…B
´Ô³†
Ü´Ò†
úüÚ†K
޵üª‡"
äµч
útÙ‡
Íçì‡
úüô‡J
¹¶È
ú<ˈ
Ï¥ü׈/
«£¼‹‰
ã£ü§‰2
ã¢äÞ‰
Öüÿ‰+
ã·¯Š
úü·Ša
^ let int_stream = int_stream.timeout_repeating(tokio::time::interval(Duration::from_secs(1)));Áä
𸾋
úüÆ‹C
¤¹üŽŒ9
ò¹üÌŒ9
¶ºüŠ9
úºüÈ6
¾»ƒŽ
úü‹ŽU
Œ¼üåŽL
ì¼ü¶9
ò¹üô2
Ò½ü«9
¶ºüé9
úºü§‘6
¾»â‘
úüê‘G
ɾü¶’?
›¿üú’H
å¿üÇ“>
¸ÀŠ”
úü’”9
ò¹üД6
¾»<‹•
¿¥<—•
Ï¥£•
úü«•J
G Timeout errors will be continuously produced at the specified intervalÁüú•,
) until the wrapped stream yields a value.Á«–
ú<³–
Ï¥ü¿–D
”üˆ—
ã£ü¤—<
ñÃäå—
Öü†˜`
] let interval_stream = IntervalStream::new(tokio::time::interval(Duration::from_millis(23)));Áüë˜l
i let timeout_stream = interval_stream.timeout_repeating(tokio::time::interval(Duration::from_millis(9)));ÁüÜ™
‰Æš
úü‰šN
K // Multiple timeouts will be received between values in the source stream.ÁüÜš5
™Çü–›N
ÙÇüé›S
P assert!(timeout_stream.try_next().await.is_err(), "expected a second timeout");ÁüÁœF
C // Will eventually receive another value from the source stream...ÁüŒM
J assert!(timeout_stream.try_next().await.is_ok(), "expected non-timeout");Á
¿¥
Ï¥»Å¿„ü
Äö
ŒÊž
»ø¢µµˆŒ·ê?£¸á<£? è…q®Xf»¨¨Ì€,¨Ÿ
л$ܞ
á<Dâž
üÔ¥V
üîŸ;
8 Slows down a stream by enforcing a delay between items.Á® 
úü¶ R
O The underlying timer behind this utility has a granularity of one millisecond.Á¡
úl•¡
# ExampleÁ§¡
úô¯¡
 Create a throttled stream.Á”Ò¡
 ```rust,no_runÁäé¡
ÖüŠ¢
 use tokio_stream::StreamExt;Á¯¢
ú´·¢
 # async fn dox() {ÁüÒ¢V
S let item_stream = futures::stream::repeat("one").throttle(Duration::from_secs(2));Áì­£
 tokio::pin!(item_stream);ÁÏ£
úT×£
 loop {Áüæ£>
; // The string will be produced at most every 2 secondsÁü©¤3
0 println!("{:?}", item_stream.next().await);Á,á¤
±¥<ë¤
¿¥<÷¤
Ï¥»Å¿„‰¥
ă¥
D×¥
»ÖÊöˆމ¼ˆê…¼¤‰¼Šê?¼²Dý&ž)J»¨¨Ì€,¤¦
Ñ»$à¥
ê…Dæ¥
ü‘¶r
üݦ[
X Batches the items in the given stream using a maximum duration and size for each batch.Á½§
úüŧL
I This stream returns the next batch of items in the following situations:Áü–¨Z
W 1. The inner stream has returned at least `max_size` many items since the last batch.Áüõ¨T
Q 2. The time since the first item of a batch is greater than the given duration.ÁüΩ)
& 3. The end of the stream is reached.Áü©
úü„ªd
a The length of the returned vector is never empty or greater than the maximum size. Empty batchesÁüíª:
7 will not be emitted if no items are received upstream.Á¬«
úd´«
# PanicsÁÅ«
úüÍ«.
+ This function panics if `max_size` is zeroÁ€¬
úlˆ¬
Ùßš¬
ú\¢¬
΢䲬
Ö¤Ó¬
­üì¬2
ã¢Ü£­
 use futures::FutureExt;Áí
ú”Ë­
·žÜâ­
 # async fn _unused() {}Áü‚®D
”ìˮ
ñžüå®0
- let iter = vec![1, 2, 3, 4].into_iter();Áüš¯)
& let stream0 = stream::iter(iter);Áȯ
úüЯ'
$ let iter = vec![5].into_iter();Áüü¯(
% let stream1 = stream::iter(iter)Áü©°Q
N .then(move |n| time::sleep(Duration::from_secs(5)).map(move |_| n));Áÿ°
úü‡±"
 let chunk_stream = stream0ÁÜ®±
 .chain(stream1)Áüα7
4 .chunks_timeout(3, Duration::from_secs(2));Áüв"
 tokio::pin!(chunk_stream);Á±²
úü¹²$
! // a full batch was receivedÁüâ²A
> assert_eq!(chunk_stream.next().await, Some(vec![1,2,3]));Áü¨³;
8 // deadline was reached before max_size was reachedÁüè³=
: assert_eq!(chunk_stream.next().await, Some(vec![4]));Áüª´%
" // last element in the streamÁüÔ´=
: assert_eq!(chunk_stream.next().await, Some(vec![5]));Á,–µ
±¥< µ
Ï¥»Å¿„²µ
Ĭµ
²|ýµ
t”¶
»ÖÊÑѵ…Óê?ØÔÚ…ØÕê…ØÖú…Ø×‡†Ø¯ó<{6¹»¨¨Ì€,ý¶
Ò»$£¶
max_sizeÁD©¶
ê…Dº¶
üݽB
ü‰¸^
[ Turns the stream into a peekable stream, whose next element can be peeked at without beingÁlì¸
consumed.Á\þ¸
΢ü޹2
ã¢Ź
ú”͹
·žÜä¹
Üìü„ºD
”ìͺ
ñžüçº0
Ÿíüœ»7
4 let mut stream = stream::iter(iter).peekable();ÁØ»
úüà»5
2 assert_eq!(*stream.peek().await.unwrap(), 1);Áüš¼5
‹ùüÔ¼4
1 assert_eq!(stream.next().await.unwrap(), 1);Áü½5
2 assert_eq!(*stream.peek().await.unwrap(), 2);Á,ǽ
±¥<ѽ
Ï¥Dà½
ȧ
ß
¦wá
,â
ê?­ÙÍÇÒà•»¨¨Ì€,™¾
Ó»$é½
ü˾2
íÕÕÎìõ²о
θ4÷¾
õ²ü­¿˜
„°¿
B–Ú–Ú–Ú
ÖœÜʌ܌܌„¿üýA> Adapters for [`Stream`]s created by methods in [`StreamExt`].Á…H,ûâ܃üN4‚ÑÝêÝQLŠþÞƒÎX$•í ߪâZ
àÄÀ]D ¾
áÝ£`,ªë
âó¦wD±ß
㧦f$»Í äÎhLÁò å³»k$ÌŸ æÉÚmLÚÄ çââp$åõ èþµ…ÑüðÈŽÝý·ˆŒ„¾µþ¸ŒÞdgTWDG47$'ôöâäÐÒ¾À¬®šœL‘,•ö¤›4 Eéê§çû\&éëçûéë–ñB„¾éìk<XÌéî·$aœØéïlÌnt7HTK9;(*Ô‚¥ññ×Ê ¸Ñ
ü  ¥óó×Ê ¬¸Ñ
üÄ ¥õõ×Ê Ð¸Ñ
üÏ#üé)& Creates a stream that yields nothing.Áúü—DA The returned stream is immediately ready and returns `None`. UseÁüÜLI [`stream::pending()`](super::pending()) to obtain a stream that is neverÁ ready.Á´úÍçÇú„Ë“÷ÜúÏ¥üè2ã¢úüŸ/«£¼Ïã£üç*' let mut none = stream::empty::<i32>();Áúü–(% assert_eq!(None, none.next().await);Á<¿¿¥Ï¥¸Ñ¥÷÷×Ê â
öˆ Ü¥ùù×Ê ¸ÑúûüFGHüû"$øøˆ üÅJšœ„¾„¾–ñ†¾ ˜X$]È=„kt• š¸Ñ ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åœœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙˆ ø Üø
ûˆ  èü·- ¸Ñ–Úø Äø
üˆ îŒîŒˆˆ¤›4 E§–ñ#„¾k<9Ì·$BœØlVtCT,46#%ÌöšÍìÞÒ û¢Ò
ü Dü”@= Converts an `Iterator` into a `Stream` which is always readyÁäÕ to yield the next value.ÁòúüöIF Iterators in Rust don't express the ability to block, so this adapterÁüÀ74 simply always calls `iter.next()` and returns that.ÁøúÏ¥´„‡áü›2ã¢ÎúüÒ0- let mut stream = stream::iter(vec![17, 19]);Áƒúü‡.+ assert_eq!(stream.next().await, Some(17));Áü¶.+ assert_eq!(stream.next().await, Some(19));Áüå*—ê<¿¥<˜Ï¥ÞÒˆˆ˜€Šù´€> Ó…”ÇÞÒÉLšÏ ¬ÇLÞÒ
ˆÞÒ´ ¯%'ü®1šÏ ³ùMÞÒ¢ÒŒŽFGHŽ24ŠŠÞÒúMü€UžŸ „¾„¾–ñ†¾ ˜X$]È=„kt• ž¢Ò ŸÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾å œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙΖŠ Š
ÞÒ$‘ûÔ§üí
-
¡ ¡¢Ò–ÚŠ ú
Š
ŽÞÒ
%%˜€$ ˆ¤›4E§³
4&‰T–ñ=„¾k<SÌ·$\œØš,ƒnpd ^t2NTF?A.0Ì’šœœÏ ¼Ó
ü¯#ü°85 Creates a stream that emits an element exactly once.ÁéúüíOL The returned stream is immediately ready and emits the provided value once.Á½úÍçÐúÏ¥üÜ2ã¢úü“/«£¼Ãã£üÛ" // one is the loneliest numberÁüþ" let mut one = stream::once(1);Á¡úü¥*' assert_eq!(Some(1), one.next().await);ÁÐúüÔ" // just one, that's all we getÁü÷'$ assert_eq!(None, one.next().await);Á¿¥Ï¥ˆ Ó¥žž×Ê »
ˆ »Ô‘¥  ×Ê Ó¡¢£FGH£¢"$ŸŸˆ üÆO¢£¤„¾„¾–ñ†¾ ˜X$]È=„kt• ¢Ó £ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾å¤’ŒŸ áŸ
¢ˆ ûÔíüÒ-¥ ¥Ó–ÚŸ ߟ
£ˆ 77JJ´¤›4 E§¨§çû\&§©çû§©–ñB„¾§ªk<X̧¬·$aœØ§­lÌnt7HTK9;(*䈥¯¯×Ê €Ô
ü¨"¥±±×Ê ´€Ô
üÎ"¥³³×Ê Ú€Ô
üÇ'üõ(% Creates a stream that is never readyÁžúü¢:7 The returned stream is never ready. Attempting to callÁüÝ?< [`next()`](crate::StreamExt::next) will never complete. UseÁüB? [`stream::empty()`](super::empty()) to obtain a stream that isÁüà,) immediately empty but returns no values.Áút‘Íç ú„¤“÷µú
```no_runÁüÇ2ã¢úú”þ·ž¬‘ñžü§1. let mut never = stream::pending::<i32>();ÁÙúüÝ# // This will never completeÁÜ never.next().await;Áú¼¡ unreachable!();Á±¥<¿Ï¥€Ô¥µµ×Ê Ü
´ˆ ì¥··×Ê €Ô¸¹ºFGH¹º"$ˆ üÅJ¦§¨„¾„¾–ñ†¾ ˜X$]È=„kt• ¦€Ô §ÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾å¨’Œ Ü
¹ˆ  èü³ -© ©€Ô–Ú À 
ºˆ \\nnƒœ¤›4 E¾¿§Y4% ¾Àpoll_fnÁ<> Ç€¾ÁŽ$Vše¾ÂŽ e¾Â–ñj„¾¾Ãÿñ,¥‚¾Åk<†Ì¾Æ·$œØ¾ÇlÆœµ¤1Ÿ|Kl`kLsZ\IK79Ô«6œÉ§ÊÉÊÍìšÕ °6Íì Õ ³6êÔËÍÏÐÑÔ×ÚÛÜÝÞßáCE?AüÏ:3üÌ6@= An iterator visiting all key-value pairs in arbitrary order.Á7úü™7.+ The iterator element type is `&'a (K, V)`.ÁÌ7útÔ7Íçç7ú<ï7Ï¥üû7+( use tokio_stream::{StreamMap, pending};Á«8úü³8# let mut map = StreamMap::new();ÁÛ8úüã8&# map.insert("a", pending::<i32>());ÁüŽ9 map.insert("b", pending());Áü²9 map.insert("c", pending());ÁÖ9úüÞ9%" for (key, stream) in map.iter() {Áüˆ:,) println!("({}, {:?})", key, stream);Á,¹:±¥<Ã:Ï¥$Ö:ª ªêÔšÕ ÕªÌÈ Û:È
ËšÕ Õ$Ü:èÌå:Ë8ÊÊËÄlÄl˜€Çlµ ™lÈl
end_or_lenÁ™lÉl˜ï™lŒœjSž8ÆÕÍìšÕ Õ8ÌšùMÿ»Äê:ÿ»úM 8ÆÕtó:÷»É–¼'¦¼Ëü¿??ü¬;HE An iterator visiting all key-value pairs mutably in arbitrary order.Áù;úü<2/ The iterator element type is `&'a mut (K, V)`.Á¸<útÀ<ÍçÓ<ú<Û<Ï¥üç<+—=úüŸ=#жÇ=úüÏ=&‰·üú=¹·üž>â·Â>úüÊ>)& for (key, stream) in map.iter_mut() {Áüø>,Ƹ,©?±¥<³?Ï¥DÆ?« «êÔšÕ Õ«ÎÈ Ï?È
ÍšÕ Õ$Ô?øÍÝ?!Í8ËËÍÜlÜlIterMutÁßlµ ™làl¼º™lál˜ï™lÚ½íDþïl%8ÆÕÍìšÕ Õ8ΘùMÝÁäâ?ÝÁúM 8ÆÕ”ë?ÕÁÇôÁ'„ÂÍü”Cü¬@! Creates an empty `StreamMap`.ÁÒ@úüÚ@JG The stream map is initially created with a capacity of `0`, so it willÁü©A1. not allocate until it is first inserted into.ÁßAútçAÍçúAú<BÏ¥üŽB+( use tokio_stream::{StreamMap, Pending};Á¾BúüÆB=: let map: StreamMap<&str, Pending<()>> = StreamMap::new();Á<ˆCÏ¥CêÔÈÈ
ÏšÕ ÕüG8üçC=: Creates an empty `StreamMap` with the specified capacity.Á©Dúü±DLI The stream map will be able to hold at least `capacity` elements withoutÁü‚EGD reallocating. If `capacity` is 0, the stream map will not allocate.ÁÎEútÖEÍçéEú<ñEÏ¥üýE+»Ã­FúüµFIF let map: StreamMap<&str, Pending<()>> = StreamMap::with_capacity(10);Á<ƒGÏ¥lGêÔÈÈ
ÐšÕ ÕÆ6D¤Gü‡L.ü¦H=: Returns an iterator visiting all keys in arbitrary order.ÁèHúüðH)& The iterator element type is `&'a K`.ÁžIút¦IÍç¹Iú<ÁIÏ¥üÍI+ýIúü…J#ж­JúüµJ&‰·üàJ¹·ü„Kâ·¨KúܰK for key in map.keys() {ÁäÐK println!("{}", key);Á,ñK±¥<ûKÏ¥$ŽL¬ ¬êÔšÕ Õ¬ÒÈ “LÈ
ÑšÕ Õ$”LÀÎLÑ8ÌÌÑâ­â­âZå­ùæ­±Å@Iœóë ¶¥ÿ»ÓšÕ Õ±¼ 8šÕÍìšÕ Õ8Ò©ùMÏœ¢LÏúMéÎL«LùÎÒ˜Ï!¨ÏÑDÐLÑÜàÓõàÓ“áÓÓÑÓšÕ Õ ÆÕ šÕüÌP0üçL74 An iterator visiting all values in arbitrary order.Á£Múü«M)& The iterator element type is `&'a V`.ÁÙMútáMÍçôMú<üMÏ¥üˆN+¸NúüÀN#жèNúüðN&‰·ü›O¹·ü¿Oâ·ãOúüëO  for stream in map.values() {ÁüP! println!("{:?}", stream);Á,¶P±¥<ÀPÏ¥4ÓP­ ­êÔšÕ Õ­ÕÈ ÚPÈ
ÔšÕ Õ$ÛPÀÏäPÔ8ÍÍÔâ­â­âZå­ùæ­±Å@Iœóë ¶¥ÿ»ÖšÕ ÕäÎ 8 ÕÍìšÕ Õ8Õ§ùM×ÕœéP×ÕúM¿ÕLòPÏÕÐîÕ!þÕÔD—QÔÜàÖõàÖ“áÖÖÔ֚ՠղР Õü£U<ü®Q?< An iterator visiting all values mutably in arbitrary order.ÁòQúüúQ-* The iterator element type is `&'a mut V`.Á¬Rút´RÍçÇRú<ÏRÏ¥üÛR+‹Súü“S#ж»SúüÃS&‰·üîS¹·ü’Tâ·¶Túü¾T$! for stream in map.values_mut() {ÁüçT!œÒ,U±¥<—UÏ¥TªU® ®êÔšÕ Õ®ØÈ µUÈ
ךՠÕ$ºUàÐÃU×8ÎÎ×â­â­âZ
$…¯4„¯Œû®$¤¯Œ RandomStateÁ\ׯÖJ\\ÿ¯Åeˆ AtomicU32ÁL¯°˜ÂË<ç°½ÀŠË¾ÀŠü»¯'{´ô¯m䜰Uüʰ$FÌý°<„±¤]¤]V¦]Á‚]üß3ø¤”&Bܹ±$DZ
Œl«¸åÕŽü¹(›¹åÕ
Ž…:$Ÿ¹üü».TмÆ ÆåÕ •¼
$–¼¹ œ¼ÌžDȾƒÇ ÇåÕ Ѿ
$Ò¾ü‰Á)d—Á
¹ ¤Á,½ÂÜàõà“á åÕ ¬Õ„í°³¤›4 E§¾ò\)–ñD„¾k<YÌ·$bœØšlXl:HLM9;(*äÏ
¤œœÍìÛÉ Ô
ïÖžìœ üò
%" Create a new `StreamNotifyClose`.Á£ ÛÉïÖ
ÛÉê?4§ üè $ü  Get back the inner `Stream`.Á¦ úü® 52 Returns `None` if the stream has reached its end.ÁTï ïÖÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÛÉ
žÛÉ ü«
<¤  î¥ °
EÛÉ
ïÖ¡¢¤FGH¤¢13

ŸŸÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÛÉXL“ÈÉÊ„¾„¾–ñ†¾ ˜X$]È=„kt• ÈïÖ ÉÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åʜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙïÖFŸ «Ÿ
¢ÛÉûÔ·¢Üà£õ࣓ᣣ¢£ÛÉ„¾„¾–ñ†¾ ˜X$]È=„kt• Ûɜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃƒªÄïüÌ-Ë ËïÖ–ÚŸ ÙŸ
¤ÛÉá¤Üà¥õ॓ᥥ¤¥ÛÉ„½ü‡¤Ã¬ä­ühPM A wrapper around [`tokio::sync::mpsc::Receiver`] that implements [`Stream`].Á¹úÙßËúÏ¥Ô׊üò/, use tokio_stream::wrappers::ReceiverStream;Áü¢ ÐàÃúüÇ/«£ü÷NK # async fn main() -> Result<(), tokio::sync::mpsc::error::SendError<u8>> {ÁüÆ$! let (tx, rx) = mpsc::channel(2);Á¼ë tx.send(10).await?;Á¼ƒ tx.send(20).await?;Áü›*' # // prevent the doc test from hangingÁ
drop(tx);ÁÔúüØ-* let mut stream = ReceiverStream::new(rx);Áü†.+ assert_eq!(stream.next().await, Some(10));Áüµ.+ assert_eq!(stream.next().await, Some(20));Áüä*—êd # Ok(())Á¿¥Ï¥¬úü°GD [`tokio::sync::mpsc::Receiver`]: struct@tokio::sync::mpsc::ReceiverÁüø# [`Stream`]: trait@crate::StreamÁt¸¥©©×Ê ÇÛŸyI¤‡ç¡n|ª ”Ð ¨¨£ (¥7¥¬¬×Êl¿cˆ ÇÛŸ­Àc­ŽUWÌÍÎ ÌÛŸ Í c cˆ¢cµ
 `£cÊ­ `àB¤GS
΋µ«¥«
­ˆ þ±üà% üqY V A wrapper around [`tokio::sync::mpsc::UnboundedReceiver`] that implements [`Stream`].ÁË ú ÙßÝ ú Ï¥Ôé Šü„8 5 use tokio_stream::wrappers::UnboundedReceiverStream;Áü½ ÐàÞ úüâ/ «£ü’N ¹²üá- * let (tx, rx) = mpsc::unbounded_channel();ÁŒ  tx.send(10)?;ÁŒ¡  tx.send(20)?;Áü³* ÿ³ ²´ì úüð6 3 let mut stream = UnboundedReceiverStream::new(rx);Áü§. ŒµüÖ. ĵü…* —ê ‰¶ ¿¥ Ï¥Í úüÑY V [`tokio::sync::mpsc::UnboundedReceiver`]: struct@tokio::sync::mpsc::UnboundedReceiverÁü«# –·¼ë ¥¯¯×Ê ƒ †¡#†²´tè#° ÜŒ '®®Ì¡(Ø 8¥²²×Êlʹƒ †¡³Àc³ˆMOÏÐÑ Ï†¡ Рc cˆ¢cµ
 `£cÊ­ `àB¤GS
Ñ‹µ±Ø ±
³ˆ ö±üdø»Å¿À
ɤ›4 E´µ§–ñ! „¾´k<6 Ì´¸·$? œØ´¹InstantÁ<X óV´»‚¢Da —W´¼l †l sL* dfSU\J >@-/œ£ µ¢¾¿üä& ü½"  Create a new `IntervalStream`.Áë ø¢µ¢½½
¾á<Dï üà# ü¹"  Get back the inner `Interval`.ÁTç µ¢ø¢½½
¿ ô¢ µ¢ÁÂÃFGHÃÂLÇ $Ì ÀÀóVóVËÃôVÀ¢U<9¥²Ö<‹½üá U Lä ÒÓÔ„¾„¾–ñ†¾ ˜X$]È=„kt• Òµ¢ ÓÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åԜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÒÇÀ ü À
ÂûÔˆ
üï
- Lò
Õ Õµ¢–ÚÀ ü
À
Ã
üà ' µ¢ÅâÅìñ Ö Öµ¢ Öø¢Ä û Ä
Å ü® ' µ¢ÇåÇüÜ % 4ß × ×µ¢ ×ø¢Æ æ Æ
Ç Ä’Ý£Ìï üm= : A wrapper around [`Interval`] that implements [`Stream`].Á« ú Ùß½ ú Ï¥üÉ3 0 use tokio::time::{Duration, Instant, interval};Áüý/ , use tokio_stream::wrappers::IntervalStream;Áü­ ÐàÎ úüÒ/ «£¼‚ ã£üš  let start = Instant::now();Áüº7 4 let interval = interval(Duration::from_millis(10));Áüò3 0 let mut stream = IntervalStream::new(interval);Áœ¦  for _ in 0..3 {Áüº4 1 if let Some(instant) = stream.next().await {ÁüïG D println!("elapsed: {:.1?}", instant.duration_since(start));Á Ї ±¥ ¿¥ Ï¥× úüÛ. + [`Interval`]: struct@tokio::time::IntervalÁüŠ# –·9tú µ¢°Aâ¹ö^vÊ| , ´ÉÉø¢(· :µ¢ÌÀcÌ"$ØÙÚ Øµ¢ Ù c cˆ¢cµ
 `£cÊ­ `àB¤GS
Ú‹µË· Ë
ÌÆ±ÌdÊ »ݶpM°G¢
Ϋ 

⤛4 !EÍΧioÁ!¦ÍÏ–ñ.!„¾ÍÐk<C!ÌÍÒ·$L!œØÍÓDirEntryÁDc!À ÍÕÈ£<m!¯ ÍÖl!<!‰l$!yL7!jlY[LW!CE24”Ò!
÷£ØÙü‘%!üë!! Create a new `ReadDirStream`.Á˜!º¤÷£××
Ø“>Dœ!ü‹"!üå!! Get back the inner `ReadDir`.ÁT!÷£º¤××
Ù$!ìÌ!
÷£ÛÜFGÜ!$õ!ÚÚÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
À À °ÖÁ file_typeÁÊÂ ÀÊŸ ´4u
°âËü— X!Lš !ÛÜÝ„¾„¾–ñ†¾ ˜X$]È=„kt• Û÷£ ÜÌÌkÎÛî¸Ïîî¸Ð‡ï¸Ñ˜ï¸Ò­ï¸f'EwÚ]¾åݜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ÷£FÚ ² !Ú
Ü$¨ !ûÔ¾ !ü¹
%!
÷£ÞâÞäå
!4è
!Þ Þ÷£ Þº¤Ý ï
!Ý
Þ
!ü¡ %!
÷£àåàüÍ $!4Ð !ß ß÷£ ߺ¤ß × !ß
à !¼ú ï£Ä !üxG!D A wrapper around [`tokio::fs::ReadDir`] that implements [`Stream`].ÁÀ!ú!ÙßÒ!ú!Ï¥äÞ! use tokio::fs::read_dir;Áüû;!8 use tokio_stream::{StreamExt, wrappers::ReadDirStream};Á·!úü»/!«£üë.!+ # async fn main() -> std::io::Result<()> {Áüš$!! let dirs = read_dir(".").await?;Áü¿,!) let mut dirs = ReadDirStream::new(dirs);Áüì-!* while let Some(dir) = dirs.next().await {Á¼š! let dir = dir?;Áü²-!* println!("{}", dir.path().display());Á!±¥!‰¶!¿¥!Ï¥ƒ!úü‡5!2 [`tokio::fs::ReadDir`]: struct@tokio::fs::ReadDirÁü½#!–·;l«!÷£Ys°1žz…ãt¿!,¿!Íâ⺤(ê!<÷£åÀcå"$àáâ à÷£ á c cˆ¢cµ
 `£cÊ­ `àB¤GS
⋵äê!ä
寱Ìù&•º´.I&º3futures do nothing unless you `.await` or poll themÁHLè äçíèééèç¹ôö Êô  Ò¥äá&“»‰¥v+b œÝXêëìò BDGIE4 Eææ£õ^ « EææØ¥w$™ Eææ”í”í•í¶ñ yaDŸd¤†ì('‰ Iäîíïðîïð¹ôÊô¿cÒ¥ ¿cØ¥'‚ ‰¥ñÀcñPSWZ¡£ãäå ㉥ ä c cˆ¢cµ
 `£cÊ­ `àB¤GS
勵í'‰ í
ñäҥإV±]Y(ös (üsEù(¸{2Gäôíõööôõ¹ôÊô‰¥]`Ÿ¢¦©ù(Ú•SÁ(Ý•Eøæ æææÁ?êê?Eë±Eì€@Ev+b œÝXøõ²û²íùúùú9ý~¸³}
÷õ²û²thisÁ!(Œ–hkª­±´ù*¨ÝÕ1*¨ÕQQ(ÝtAüäýíþÿþÿýüÎ쯦JÍ쵦Ræ¥A1*¤ÞäAù)ÿȯ¦A¯¦ä µ¦A-ûû‹Aê?E±E€@EЄ¦XA䯦µ¦Є¦X1*ÓÝéì+.25ÍíEûû A 䯦óúEûû Aµ¦Eûû„¾„¾–ñ†¾ ˜X$]È=„kt• Aóêù/¨ÝÕ1/¨ÕUi(®xAäíòYòX­ò1/¤Þ¿òù.ÿÈÔò áòîòƒƒÛAˆê?E±EŠ€@EË1š3qT•A䯦µ¦Ë1š3qT•ˆŠ1/ÓÝÊÍ ¸ÎEƒƒ A³ô×ÔEƒƒ Aµ¦öÚEƒƒ„¾„¾–ñ†¾ ˜X$]È=„kt• Aóêù3•‡13ù…9(Ü}Œ„¾„¾–ñ†¾ ˜X$]È=„kt• Œ‰¥ûû‹Aê?E±E€@EЄ¦XŒäҥإó13°‡ó
äҥإ!3Ň)+ù7•‡17ù…Y(Ž„¾„¾–ñ†¾ ˜X$]È=„kt• މ¥ƒƒÛAˆê?E±EŠ€@EË1š3qT•Žäҥإó17°‡ó
äҥإ!7Ň)+ù;å½0OA;ñ½AäíòN
òM
áòù(݈tÚBŠCEê?E±E€@E7¨ýiA䯦µ¦7¨ýi1;ú½¯
²
ñ
ô
ø
û
ù;ܾ<;ܾEçûFu\»Ÿ A E001 AlwaysUnpinÁ3ˆ ‰4ä\’ÎM³ôS; E001Îÿ3ˆ ‰4ä\’ÎMµ¦ši Eóêù;ÿáOAäšíœœšò^ ò] “í))*PinnedFieldsOfHelperStructÁ,ˆ Úˆ3Clœ³þ(Á;ŒÁæ¥1;È¿š  Ü ß ã æ ©?ûéPy?êE³Á?ûé³³!ù?Ïê6P¥ŸŸ×Ê ?ÔêŒ"ˆ ¹?×ꈠ ù?‘ëFPä¡í¢££¢¡¹ôÛ
ÊôÚ
‰¥­
°
ï
ò
ö
ù
ùH•º´.IHºÙçmLè ä¥í¦§¥¦§¹ôö Êô  ÜéáH“»°§qý¢e|ÿ‡
¨©ªò ;=@BE4 Z¤¤£õ^ « Z¤¤Ø¥w$™ Z¤¤óê(I‰ nä¬í­®­®¬¹ôâÊôàéë úëI‚ °§¯Àc¯ÖØçèé ç°§ è c cˆ¢cµ
 `£cÊ­ `àB¤GS
鋵«I‰ «
¯äҥإB±IYJös JüsZùJ¸{2lä²í³´´²³¹ôDÊôC°§ÉË#&^aehùJÚ•SÁJÝ•Zê ꤤŸD¨ê?Z©±Zª€@Zqý¢e|ÿ‡
õ²û²í·¸¸·ÿý=¸³<
µõ²û²æï!JŒ–+.fimpùL¨ÝÕ1L¨ÕvQJÝtAºä»í¼½º¼½»òýòü‰¨A1L¤Þ¿òùKÿÈÔò áòîò¹¹‹A¾ê?Z¿±ZÀ€@ZÃeü#äã#A䯦µ¦Ãeü#äã#¾¿À1LÓÝ|·º¾Á¸Z¹¹­ôÐZ¹¹Óôè~Z¹¹óôùQ¨ÝÕ1Q¨ÕziJ®xAÂäÃíÄÅÂÃÅÄòò¼Ž 1Q¤Þ¿òùPÿÈÔò áòîòÁÁÛAÆê?ZDZZÈ€@ZÚPžë1æ[‹A䯦µ¦ÚPžë1æ[‹ÆÇÈ1QÓÝILPS¸ZÁÁŽøÐZÁÁ­øèZÁÁÌøùU•‡1Uù…9JÜ}Ê„¾„¾–ñ†¾ ˜X$]È=„kt• ʰ§¹¹‹A¾ê?Z¿±ZÀ€@ZÃeü#äã#Êäҥإ±1U°‡±
Éäҥإ!UŇ)+ùY•‡1Yù…YJÌ„¾„¾–ñ†¾ ˜X$]È=„kt• ̰§ÁÁÛAÆê?ZDZZÈ€@ZÚPžë1æ[‹Ìäҥإ±1Y°‡±
Ëäҥإ!YŇ)+ù]å½0tA]ñ½AÎäÏíÐÑÎÐÑÏòD òC áòùJ݈tÍÍÚBÒŠCZÓê?ZÔ±ZÕ€@Z)îq™ÚA䯦µ¦)îq™ÚÒÓÔÕ1]ú½¬ ¯ ç ê î ñ ù]ܾ<]ܾZÍÍýÿÕÒ ZÍÍÀ íÑ ZÍÍ Ñ ZÍÍóêù]ÿátA×äØíÙÚØ×ÙÚò¿
ò¾
“í))*Î ,ˆ Úˆ3ClœŽ™ (Á]ŒÁ‰¨1]È¿é
ì
$ ' + . ©aûéuyaêZÛÛ³ÁaûéÛ³³!ùaÏê6u¥ÝÝ×Ê aÔêÆ„ ¹a×ꈠùa‘ëFuäßíàáàßá¹ô Êô °§ô ÷ / 2 6 9 ùh•º´ü¤E
IhºB Stream returned by the [`chain`](super::StreamExt::chain) method.Á
¥ã¦äãä×Ê ÿ
 
¦ª ldŒ—åæ(*-/áh“» ž
oââÁ¶ Á
oâââªYiös iüsoùi¸{2¥é¦êéê×ÊÅæªúü×ÙÜÞùiÚ•SÁiÝ•oë 릪¥ì¦íìí i’–×Êa`
ëˆ âªæï!iŒ–Žùk¨ÝÕ1k¨ÕQiÝtAï¥ð¦ñïðñÚÍ쎪ЩA1k¤ÞˆªAùjÿÈŽªAîî‹Aò¬oó­oGGǯaèSAˆªŽªGGǯaèSòó1kÓݺ½ÁÄšoî„¾–ñ†¾ ˜X$]È=„kt• Aû¶ëÉoî„¾–ñ†¾ ˜X$]È=„kt• AŽªùo¨ÝÕ1o¨Õšii®xAõ¥ö¦÷÷õöÚæ¥¤ 嵤 1o¤ÞǤ ùnÿÈÚ¤  ôôÛAø¬où­o0 äI`¯KXAˆªŽª0 äI`¯KXøù1oÓÝtw{~Koôô„¾„¾–ñ†¾ ˜X$]È=„kt• Aû¶äƒoôô„¾„¾–ñ†¾ ˜X$]È=„kt• AŽªùr•‡1rù…9iÜ}û„¾„¾–ñ†¾ ˜X$]È=„kt• û¦ªîî‹Aò¬oó­oGGǯaèSûˆ âªè1r°‡è
úˆ âª!rŇ#%ùu•‡1uù…Yiý„¾„¾–ñ†¾ ˜X$]È=„kt• ý¦ªôôÛAø¬où­o0 äI`¯KXýˆ âªè1u°‡è
üˆ âª!uŇ#%ùxå½0Axñ½Aÿ¥¦ÿÚŒ¥¤ þþÚBŠCoƒ¬o­oÓg‹D]¡AˆªŽªÓg‹D]¡ƒ1xú½

ùxܾ<xܾoþþýÿùi݈t oþþû¶oþþŽªùxÿáA¥¦ˆˆÚÃ¥¤ “í))*Î ,ˆ Úˆ3Clœ©¯ (ÁxŒÁЩ1xÈ¿" % ) , ©{ûéy{êo³Á{ûé³³!ù{Ïê6¥×Ê {ÔêÆ„ ¹{×ꈠù{‘ëF¥¦ŽŽ×Ê

¦ª

$
'
ù„•º´.I„ºÙ箥¦×Ê ß âÍìÓ« åùªaÕ'‡£¿=?BD>@á„“»4…ˆ Ó«:<¯çûFu\»Ÿâª{$°óê(…À¯¥˜¦šš˜×Ê?>¸µ 4ʹß¿câªâ¿cÓ«åùªÀcÁÃìíî ìùª í c cˆ¢cµ
 `£cÊ­ `àB¤GS
ˆ âªÓ«u±|Y†ösüsù†¸{2­¥ž¦Ÿ žŸ ×Ê×Ö¸µ Ìùª·¹òõùü÷úù†Ú•SÁ†Ý•ï ïùª¥¢¦£¤¤£¢’–×Ê£¢¸µ ˜
¡ˆ âªÓ«æï!†Œ–ÒÕÙÜ×Úùˆ¨ÝÕ¨Õ·Q†ÝtA¦¥§¦¨©©§¦¨Ú~¥¤ }Í컬|á«A1ˆ¤ÞǤ ù‡ÿÈ»¬AÚ¤ ¥¥‹Aªê?«“K¬¥K­€@^IØØØAˆªŽª»¬^IØØØª«¬­ÓÝUX\_Z]Ó¥¥„¾„¾–ñ†¾ ˜X$]È=„kt• Aˆª%Q¥¥ A»¬FX¥¥ AçûFu\»ŸŽªŽ_¥¥óôùލÝÕ¨Õ¼i†®xA¯¥°¦±²²°¯±ÚÖ¥¤ Õ´¾ Ëľ 1ޤÞǤ ùÿÈä¾ 
Ú¤ ®®ÛA³ê?´“Kµ¥K€@ }=ì~ýTAˆªŽª»¬ }=ì~ýT³´µÓÝ žÌY®®„¾„¾–ñ†¾ ˜X$]È=„kt• Aˆª®® A»¬?®® A½Á `y®®Ìøù“•‡1“ù…9†Ü}¸„¾„¾–ñ†¾ ˜X$]È=„kt• ¸ùª¥¥‹Aªê?«“K¬¥K­€@^IØØØ¸ˆ âªÓ«1“°‡
·ˆ âªÓ«!“Ň)+ù˜•‡ù…Y†º„¾„¾–ñ†¾ ˜X$]È=„kt• ºùª®®ÛA³ê?´“Kµ¥K€@ }=ì~ýTºˆ âªÓ«°‡
¹ˆ âªÓ«Ň)å½0µAñ½A¼¥½¦¾¿¿½¾¼Ú+ ¥¤ * ´¾  »»ÚBÀŠCÁê?“KÃ¥KÄ€@…ÐÉ9?w %AˆªŽª»¬…ÐÉ9?w %ÀÁÂÃÄ1ú½Ô × Û Þ Ù Ü ùܾ<ܾ»»ýÿù†݈tà »»ˆª  »»001Îÿ3ˆ ‰4ä\’ÎM»¬gï »»001Îÿ3ˆ ‰4ä\’ÎM½Á ®õ »»óêùÿáµAƥǦÈÉÈÆÇÉÚ@
¥¤ ?
´¾ 5
“í))*Î ,ˆ Úˆ3ClœçË (ÁŒÁá«1È¿¨
«
¯
²
­
°
©¢ûéêÊʳÁ¢ûéʳ³"ù¢Ïê6¥ÌÌ×Ê ¢ÔêÆ„ ¹¢×ꈠù¢‘ëF¥Î¦ÏÐÎÐÏ×Ê»º¸µ °ùªÐÓ×ÚÕØù¬•º´ü–GºD Stream returned by the [`filter`](super::StreamExt::filter) method.Á.Q streams do nothing unless polledÁÒíÒÓÒÓ§³©¸³ ­»²‹èÔÕ(*-/ᬓ»ÓÑÑõ² ÝÓÑÑû²ös ­üsÓù­¸{2ÖíØÙØÙ§³̸³Ê»²éëÞàãåù­Ú•SÁ­Ý•Óð ð»²íÛÜÜÛ ­’–§³l¸³k
Úõ²û²æïŒ–šù¯¨ÝÕ¨ÕÞÝtAÞíßààÞßÍìÒ¥&Êô%ç±A1¯¤ÞÒ¥Aù®ÿÈ
¸³
»²,
/
3
6
ùÇ•º´ü–OºL Stream returned by the [`filter_map`](super::StreamExt::filter_map) method.Á.YÓ ïíÿÿ§³´¸³ ¸ò³ï±ÞÉu^ƒr (*-/áÇ“»ëþþõ² èëþþû²ös Èüsëùȸ{2óí§³̸³Êò³– ˜ ÞàãåùÈÚ•SÁÈÝ•ëñ ñò³íˆ ˆ  È’–§³l¸³k
õ²û²æïŒ–šùʨÝÕ¨ÕûÝtAíŒ  Œ  €Ù Êôž³A1ʤު٠ùÉÿȾ٠
Š Š ‹AŽ ê?ë ±ë+†„±æAҥإ+†„±æŽ ÓÝ·º¾ÁëŠ Š èÚ °ŒëŠ Š ºÛ ùΨÝÕ¨Õþ®xAí€Ù vÊôuÿî 1Τު٠ùÍÿȾ٠
  ÛAê?ë±ë
ñâj€¬PAҥإ
ñâj€¬P” • 1ÎÓÝ  ßë  úÝ °Þë  ÌÞ ùÑ•‡ù…Ü}„¾„¾–ñ†¾ ˜X$]È=„kt• — ò³Š Š ‹AŽ ê?ë ±ë+†„±æõ²û²°‡
õ²û²Ň%'ùÔ•‡ù…„¾„¾–ñ†¾ ˜X$]È=„kt• ™ ò³  ÛAê?ë±ë
ñâj€¬Põ²û²°‡
˜ õ²û²Ň%'ù×å½0ùA×ñ½Aíœ  œ  €Ù ÁÊôÀš š ÚBž ŠCëŸ ê?ë  ±ë0äÜ›žÚƒAҥإ0äÜ›žÚƒž Ÿ   1×ú½CFJMù×ܾ<×ܾëš š ýÿùÈ݈tEëš š Ò¥ Dëš š ¹å ù×ÿáùA¢ í£ ¤ £ ¤ ¢ €Ù Êô“í))*Î ,ˆ Úˆ3Clœ¢ø (Á׌Áž³È¿dgkn©Úûéúêë¥ ¥ ³ÁÚûé¥ ³³"ùÚÏê6ú¥§ § ×Ê ÚÔêÆ„ ¹Ú×ꈠùÚ‘ëFúí© ª ª © §³Y ¸³X ò³g j n q ù㕺´.IãºÙçí¬ ­ ® ¬ ® ­ §³ýæË Êô дbìMŒ‡žÛ¯ ° ± ² 469;>@áã“»« « õ² ´« « Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¦µ Ì« « Ø¥™$º« « óêí´ µ ´ µ §³TæËSÊôRɳäý¿c¦µäúëäд· Àc· 𡤍«¹»òóô òд ó c cˆ¢cµ
 `£cÊ­ `àB¤GS
ô‹µ³ ä³
· õ²¦µØ¥m±tös åüsùå¸{2íº » ¼ » ¼ º §³äæËãÊôâдÓ Õ ÿ 
ùåÚ•SÁåÝ•õ õдí¾ ¿ À ¿ ¾ À  å’–§³°æË¯Êô®
½ õ²¦µØ¥æïŒ–ßâæéíðùç¨ÝÕ¨ÕÝtA íà Ä Å Â Ä Å à €Ù Íì޶ò¸µA1ç¤ÞªÙ ùæÿÈ޶AîòÁ Á ‹AÆ ê?Ç óTÈ ±É €@®/y}f4CAÒ¥޶µ¦®/y}f4CÆ Ç È É 1çÓÝbeilpsÓ.Á Á èÚ ì-Á Á AÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ޶Q4Á Á Óôk4Á Á óôùí¨ÝÕ¨Õ ®xAË íÌ Í Î Ë Í Î Ì €Ù Àȇ
¿ò¾߇
¤ÞªÙ ùìÿÈÿ‡

îòÊ Ê ÛAÏ ê?Ð óTÑ ±Ò €@*hô¼ZþžÂAÒ¥޶µ¦*hô¼ZþžÂÏ Ð Ñ Ò 1íÓÝƒŠŽÌLÊ Ê úÝ åKÊ Ê Aý‰

Ê Ê ­ø
Ê Ê Ìøùò•‡ù…Ü}Ô „¾„¾–ñ†¾ ˜X$]È=„kt• Ô Ð´Á Á ‹AÆ ê?Ç óTÈ ±É €@®/y}f4CÔ õ²¦µØ¥¹ °‡¹
Ó õ²¦µØ¥Ň)+ù÷•‡ù…Ö „¾„¾–ñ†¾ ˜X$]È=„kt• Ö Ð´Ê Ê ÛAÏ ê?Ð óTÑ ±Ò €@*hô¼ZþžÂÖ õ²¦µØ¥¹ °‡¹
Õ õ²¦µØ¥Ň)+ùüå½0ñ½AØ íÙ Ú Û Ú Ø Ù Û €Ù Ô
ȇ
Ó
òÒ
× × ÚBÜ ŠCÝ ê?Þ óTß ±à €@M3å´QÛAÒ¥޶µ¦M3å´QÛÜ Ý Þ ß à 1üú½}     Ž ùüܾ<üܾ× × ýÿùå݈tu × × Ò¥ t × × 001Îÿ3ˆ ‰4ä\’ÎMý‰
g\ × × [ × × óêùüÿáAâ íã ä å å ã â ä €Ù » ȇ
º ò¹ “í))*Î ,ˆ Úˆ3Clœž”
(ÁüŒÁ¸µÈ¿#
&
*
-
1
4
©ûéšyêæ æ ³Áûéæ ³³"ùÏê6š¥è è ×Ê ÔêÆ„ ¹×ꈠù‘ëFšíê ë ì ì ë ê §³6æË5Êô4дKNRUY\ù‰•º´ü…:I‰º7 Stream returned by [`fuse()`][super::StreamExt::fuse].Á»¥î î ×Ê éÁ¶éË}š–gï  á‰“»4…ší í ׌ͼ¥ñ ñ ×ÊsʹŠéÁ¶ò Àcò ŽPRö÷ø öÁ¶ ÷ c cˆ¢cµ
 `£cÊ­ `àB¤GS
ø‹µð ŠÍð
ò ˆ ú±Y‹ösüsšù‹¸{2º¥õ õ ×ÊÁ¶
œŸù‹Ú•SÁ‹Ý•šù ùÁ¶¥÷ ÷ ’–×Ê
ö ˆ æï!‹Œ–(+ù¨ÝÕ1¨ÕÄQ‹ÝtAù ¥ú ú ù Úû¶A1¤ÞǤ ùŒÿÈø ø ‹Aû ê?šp²%9JÖAˆªp²%9JÖû 1ÓÝpïšø ø „¾„¾–ñ†¾ ˜X$]È=„kt• AÐÃù¨ÝÕ1¨ÕÆi‹®xAý ¥þ ý þ ÚÑÄ¡
1¤ÞǤ ùÿÈü ü ÛAÿ ê?šy_ ¶$%\Aˆªy_ ¶$%\ÿ 1ÓÝEHp#šü ü „¾„¾–ñ†¾ ˜X$]È=„kt• AÐÃù’•‡1’ù…9‹Ü}
„¾„¾–ñ†¾ ˜X$]È=„kt• 
Á¶ø ø ‹Aû ê?šp²%9JÖ
ˆ ô 1’°‡ô
ˆ !’Ň!#ù”•‡1”ù…Y‹ƒ
„¾„¾–ñ†¾ ˜X$]È=„kt• ƒ
Á¶ü ü ÛAÿ ê?šy_ ¶$%\ƒ
ˆ ô 1”°‡ô
ˆ !”Ň!#ù–å½0ÂA–ñ½A
¥

ÚÔ

ÚB
ŠCšˆ
ê?š‰„ÛŽBiAˆª‰„ÛŽBi
ˆ
1–ú½=@ù–ܾ<ܾš

ýÿù‹݈tGš

ÐÃù–ÿáÂAŠ
¥
Š
ÚÆ“í))*Î ,ˆ Úˆ3Clœª
(Á–ŒÁû¶1–È¿ #©˜ûéÃꚌ
Œ
³Á˜ûéŒ
³³"ù˜Ïê6Ã¥Ž
Ž
×Ê ˜ÔêÆ„ ¹˜×ꈠù˜‘ëFÃ¥

×Ê÷Á¶þ ù •º´ü9I º6 Stream for the [`map`](super::StreamExt::map) method.Á.CÓ Ðí


§³¸³ ©¸Nç
z8³
(*-/á “»«

õ² Å«

û²ös ¡üs«ù¡¸{2Ôí˜


˜
§³̸³Ê©¸©
«
Þàãåù¡Ú•SÁ¡Ý•«ú ú©¸í
œ

œ
 ¡’–§³l¸³k
š
õ²û²æïŒ–šù£¨ÝÕ¨ÕÜÝtAž
íŸ
 
 
ž
Ÿ
€Ù ÊôÕ·A1£¤ÞªÙ ù¢ÿȾ٠


A¡
ê?«¢
±«…z9¢Q]qAҥإ…z9¢Q]q¡
¢
ÓÝ·º¾Á«

èÚ °Œ«

ºÛ ù§¨ÝÕ¨Õß®xA¤
í¥
¦
¥
¦
¤
€Ù vÊôuð³
¤ÞªÙ ù¦ÿȾ٠
£
£
ÛA§
ê?«¨
±«Žk4--DñAҥإŽk4--Dñ§
¨
ÓÝ  ß«£
£
úÝ °Þ«£
£
ÌÞ ùª•‡ù…Ü}ª
„¾„¾–ñ†¾ ˜X$]È=„kt• ª
©¸

A¡
ê?«¢
±«…z9¢Q]qª
õ²û²
°‡
©
õ²û²Ň%'ù­•‡ù…¬
„¾„¾–ñ†¾ ˜X$]È=„kt• ¬
©¸£
£
ÛA§
ê?«¨
±«Žk4--Dñ¬
õ²û²
1­°‡
«
õ²û²Ň%'ù°å½0Úñ½A®
í¯
°
¯
°
®
€Ù ÁÊôÀ­
­
ÚB±
ŠC«²
ê?«³
±«ØE'd´AҥإØE'd´±
²
³
ú½CFJMù°ܾ<°ܾ«­
­
ýÿù¡݈tE«­
­
Ò¥ D«­
­
¹å ù°ÿáÚAµ
í
·
·
µ
€Ù Êô“í))*Î ,ˆ Úˆ3Clœ“½
(Á°ŒÁÕ·È¿dgkn©³ûéÛ꫸
¸
³Á³ûé¸
³³"ù³Ïê6Û¥º
º
×Ê ³ÔêÆ„ ¹³×ꈠù³‘ëFÛí¼
½
½
¼