boc/aamos-ledger-rust/target/debug/deps/libtokio_stream-13014b8ba9687d79.rmeta

rust
J5
#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$É@@T·-e618e6be60e87ba2Á
gimliÁ¸
°µ~Î1‹Ñt	ðÁ€w-1f7768a68858f670Á
objectÁ
áPÃ?­À¶¼QHJ¥�-914cd6a4dbe590d1Á
memchrÁ›º«8Ór­2Ù $¨ûib‚-cf21ca6f2bb15dcdÁ
ë
‹ás«L
Ö€îâƒ×ɯŒ
-ee6f3747e38367f0Á
tokioÁü4‰Ñ�2Þ�g*–j»ª"!-c2810403ed321132Ápin_project_liteÁ·x¼+Ä`·á¨›�t—¸Íœ-2dc344ecc91b59efÁparking_lotÁ×ßÿ9È
¥É¤„±X-bf01ab60cd5c5b66Álock_apiÁEcÓŽ/ÅS}sw‡A$P-0e8055cd433fa267Á
scopeguardÁ’‰‘p ÒÞa¢ßöéqÓB-29f0bdb2ea82739eÁparking_lot_coreÁí|ŸV„E`•Ö«Ì#ÎJH-d4f765203cf287f4ÁsmallvecÁµóª§eâéU
W¹Ñ�,Å-8fb808173b3f0087ÁserdeÁFVæ¸Û•IÄÀzÍ-9c8ce3cf08540cc3Áserde_deriveÁ,w|êñ]ù¿¥­C£ð-975c43f96d83014eÁ
serde_coreÁ²€Ãb˜cÐòÅ�¾ÇÇ
-7a42419d8e43b208Á
®f©¾/ô)c§{õa“â‘-a3906971a93fd1b8Á–æ\‹±Ôcd�-»ùÀTƒ-f86f80b348d33b13ÁmioÁGù�j0ðÔ·â"FÆ#0Q-3545320490828222ÁbytesÁ�`²['3_²µÆ=üå¥-d4f44708ed5da7b6Átokio_macrosÁóÁm¹^E�¼>ŽCê
z3-074a4ab5bbda1a72Ásocket2ÁsT›¸n>~R�Ê1G/R-c161f09f0083d1e0Ásignal_hook_registryÁœ¥¿’g›´·DV<{Y<<-b3ea108dcb9d0adeÁerrnoÁÍ\Ý|#{°zŽ¡p&a”-464950f23d45b34dÁ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¥
3›

3
ö
3
†
'

8¥
8É
'

;¥
;
³
'

>¥
>÷




stream_extÁ
B
B

B£
E
E

E
E
E
E
E
E
E
E

O'aÁ
OStÁ
O—
Oæ	
E


T
Î
T—
T°

TŠ
B
Bº
Z
Z

Z
Z
Z
Z
Z
Z
Z
Z

d
Å
d
Î
d—
dæ	
Z


i
Î
i—
i°

iŠ
B
BchainÁ
o
o

o
o
o
o
o
o
o

x¥
x¦
xæ	
o


|¥
|¦
|›

|
ö
€

|
†
B
BcollectÁ
„

„


„

„

„

„

„

„

„

„
	
„


„

„

FromStreamÁ
‘
¥
„


“
¥
“
¦
“
æ	
„



—
¥
—
¦
—
°

—
Š
›

„


„


ž
InternalCollectionÁ
ž

initializeÁ
ž
extendÁ
ž
finalizeÁ
„


£
¥
„


¥
¥
¥

£
¥

½
¥

Ï
¥

Ý
„


«
¥
„


­
¥
­

£
­

½
­

Ï
­

Ý
„


³
¥
„

	
µ
¥
µ

£
µ

½
µ

Ï
µ

Ý
„



»
¥
»
¦
»
–
„


¿
¥
¿
¦
¿
–
¿

£
¿

½
¿

Ï
¿

Ý
„
sealedÁ
Ç
FromStreamPrivÁ
È
¥
È

£
È

½
È

Ï
È

Ý
Ç
InternalÁ
Î


B
B
B
BfilterÁ
Ó

Ó


Ó

Ó

Ó

Ó

Ó

Ó

Ó


Ü

Î
Ü
—
Ü
×
Ó



à

Î
à
—
à
æ	
Ó


ä

Î
ä
—
ä
›

ä

ö
ä

†
B
B
filter_mapÁ
ë

ë


ë

ë

ë

ë

ë

ë

ë


ô

Î
ô
—
ô
×
ë



ø

Î
ø
—
ø
æ	
ë


ü

Î
ü
—
ü
¥
ü
›

ü

ö
ü

†
B	
BfoldÁ
„
„

„
„
„
„
„
„
„
„

Ž
Î
Ž“
Ž—
Žæ	
„


“
Î
““
“—
“°

“Š
B

BfuseÁ
š
š

š
š
š
š
š
š

¢¥
¢æ	
š


¥¥
¥›

¥
ö
¥
†
B
BØ
«
«

«
«
«
«
«
«

³
Î
³—
³×
«


·
Î
·—
·æ	
«

»
Î
»—
ȴ
»›

»
ö
À	
Á	
»
†
B
B	map_whileÁ
Å
Å

Å
Å
Å
Å
Å
Å

Í
Î
Í—
Í×
Å


Ñ
Î
Ñ—
Ñæ	
Å

Õ
Î
Õ—
Õ¥
Õ›

Õ
ö
Ú	
Õ
†
B

BmergeÁ
Þ
Þ

Þ
Þ
Þ
Þ
Þ
Þ

æ¥
æ¦
ææ	
Þ


ê¥
ê¦
ê›

ê
ö
ê
†
Þ
ö
ð¥
ð¦
B
Bó	
ô
ô

ô
ô
ô
ô
ô
ô
ô

ý
Å
ý
Î
ýæ	
ô


�
Î
�°

�Š
B
BskipÁ
†
†

†
†
†
†
†
†
†

�
Î
�×
†


’
Î
’æ	
†

•
Î
•›

•
ö
•
†
™	
B
B
skip_whileÁ
œ
œ

œ
œ
œ
œ
œ
œ
œ

¥
Î
¥—
¥×
œ


©
Î
©—
©æ	
œ

­
Î
­—
­›

­
ö
­
†
B
BtakeÁ
´
´

´
´
´
´
´
´
´

½
Î
½×
´


À
Î
Àæ	
´

Ã
Î
Û

Ã
ö
Æ	
Ã
†
B
B
take_whileÁ
Ê
Ê

Ê
Ê
Ê
Ê
Ê
Ê

Ò
Î
Ò—
Ò×
Ê


Ö
Î
Ö—
Öæ	
Ê

Ú
Î
Ú—
Ú›

Ú
ö
Þ	
ß	
Ú
†
B
BthenÁ
ã
ã

ã
ã
ã
ã
ã
ã
ã

ì
Î
ìFutÁ
ì—
ì×
ã


ñ
Î
ñ
Ÿ.
ñ—
ñæ	
ã

ö
Î
ö—
ö
Ÿ.
ö›

ö
ö
ö
†
ü	
B
Btry_nextÁ
ÿ
ÿ

ÿ
ÿ
ÿ
ÿ
ÿ
ÿ
ÿ
ÿ

‰
Å
‰
Î
‰æ	
ÿ


�¥
�–
�
Î
�°

�Š
B
BpeekableÁ
”
”

”
”
”
”
”
”
”

�¥
�æ	
�peekÁ
 
 	
”


£¥
£›

£
ö
B
B	StreamExtÁ
¨ó	
¨
œ/
ª¥
ª–
¨Ø
­¥
­—
¨
Î%
°¥
°—
¨
Þ-
³—
³
Ÿ.
¨
ù&
¶¦
¨
á
¸—
¨
�!
º¥
º—
¨
»#
¨
ª+
¨
µ,
¿—
¨
û(
¨
†*
—
¨£
Ä—
¨º
Æ—
¨
ø
Ȧ
¨
­"
Ê“
Ê—
¨
í
Í¥
¨timeoutÁ
¨timeout_repeatingÁ
¨throttleÁ
¨chunks_timeoutÁ
¨
¦0
B

Ô
Î
Bmerge_size_hintsÁ




adaptersÁ
Ú
Ú

Ú
Ú
Ú
Ú
Ú
Ú
Ú
Ú	
Ú

Ú
Ú
Ú

emptyÁ
é
é

é
é
é
é
é

ð¥
é


ò¥
é

ô¥
é
Ã5
ö¥
é

ø¥
ø›

ø
ö
ø
†



ù
€
€

€
€
€
€

†š
€ù
ˆš
€


Šš
Š›

Š
ö
Š
†


	
onceÁ
’
’

’
’
’
’
’
’
’

›š
’
Ã7
�¥
’


Ÿ¥
Ÿ›

Ÿ
ö
Ÿ
†




pendingÁ
§
§

§
§
§
§
§

®¥
§


°¥
§

²¥
§
Ä8
´¥
§

¶¥
¶›

¶
ö
¶
†





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Á
û
Å
û
Î
û—
û
ËD
û±
û
áD
ò
ProjectionRefÁ
ƒ
þE
ƒ
Å
ƒ
Î
ƒ—
ƒ
ËD
ı
ƒ
áD
óprojectÁ
‹
þE
óproject_refÁ
�
þE
ò__OriginÁ
�
þE
�
Å
�
Î
�—
�__dummy_lifetimeÁ
�
ËD
�±
�
áD
ò


˜
þE
˜
Å
˜
Î
˜—
òMustNotImplDropÁ
ò

ž¥
ò

 
Å
 
Î
 —
Z	AnyFutureÁ
¤
Å
¤
Î
¤—
¤
ËD
¤±
¤
áD
Z

«
Å
«
Î
«—
«×
Z
°

±
Å
±
Î
±—
°
´E
µ
Å
µ
Î
µ—
°
ìE
¹
þE
¹
Å
¹
Î
¹—
¹
ËD
¹±
¹
áD
°
¼F
Á
þE
Á
Å
Á
Î
Á—
Á
ËD
Á±
Á
áD
±
‰G
É
þE
±
 G
Ë
þE
°
»G
Í
þE
Í
Å
Í
Î
Í—
Í
ëG
Í
ËD
ͱ
Í
áD
°


Ö
þE
Ö
Å
Ö
Î
Ö—
°
ÀH
°

Ü¥
°

Þ
Å
Þ
Î
Þ—
oChainÁ
â¥
â¦
â¬
â­
o
ç

è¥
è¦
ç
´E
ë¥
ë¦
ç
ìE
î
þE
î¥
î¦
î¬
î­
ç
¼F
ô
þE
ô¥
ô¦
ô¬
ô­
è
‰G
ú
þE
è
 G
ü
þE
ç
»G
þ
þE
þ¥
þ¦
þ
ëG
þ¬
þ­
ç


…
þE
…¥
…¦
ç
ÀH
ç

Š¥
ç

δ
Œ¦
„
CollectÁ
�¥
�¦
�”
�
ËD
�
collectionÁ
�_outputÁ
�
áD
„


—¥
—¦
—”
—×
„

œ

�¥
�¦
�”
œ
´E
¡¥
¡¦
¡”
œ
ìE
¥
þE
¥¥
¥¦
¥”
¥
ËD
¥
ôO
¥
†P
¥
áD
œ
¼F
®
þE
®¥
®¦
®”
®
ËD
®
ôO
®
†P
®
áD
�
‰G
·
þE
�
 G
¹
þE
œ
»G
»
þE
ȴ
»¦
»”
»
ëG
»
ËD
»
ôO
»
†P
»
áD
œ


Å
þE
Å¥
Ŧ
Å”
œ
ÀH
œ

Ë¥
œ

Í¥
ͦ
Í”
Ó
FilterÁ
Ñ
Î
Ñ—
Ñ
ËD
ѱ
Ó

Ö

×
Î
×—
Ö
´E
Ú
Î
Ú—
Ö
ìE
Ý
þE
Ý
Î
Ý—
Ý
ËD
ݱ
Ö
¼F
ã
þE
ã
Î
ã—
ã
ËD
ã±
×
‰G
é
þE
×
 G
ë
þE
Ö
»G
í
þE
í
Î
í—
í
ëG
í
ËD
í±
Ö


ô
þE
ô
Î
ô—
Ö
ÀH
Ö

ù¥
Ö

û
Î
û—
ë
	FilterMapÁ
þ
Î
þ—
þ
ËD
þ±
ë

ƒ	

„	
Î
„	—
ƒ	
´E
‡	
Î
‡	—
ƒ	
ìE
Š	
þE
Š	
Î
Š	—
Š	
ËD
Š	±
ƒ	
¼F
�	
þE
�	
Î
�	—
�	
ËD
�	±
„	
‰G
–	
þE
„	
 G
˜	
þE
ƒ	
»G
š	
þE
š	
Î
š	—
š	
ëG
š	
ËD
š	±
ƒ	


¡	
þE
¡	
Î
¡	—
ƒ	
ÀH
ƒ	

¦	¥
ƒ	

¨	
Î
¨	—
„
FoldFutureÁ
«	
Î
«	“
«	—
«	
ËD
«	accÁ
«	±
«	
áD
„

³	
Î
³	“
³	—
³	×
„
¸	

¹	
Î
¹	“
¹	—
¸	
´E
½	
Î
½	“
½	—
¸	
ìE
Á	
þE
Á	
Î
Á	“
Á	—
Á	
ËD
Á	
ÔY
Á	±
Á	
áD
¸	
¼F
Ê	
þE
Ê	
Î
Ê	“
Ê	—
Ê	
ËD
Ê	
ÔY
Ê	±
Ê	
áD
¹	
‰G
Ó	
þE
¹	
 G
Õ	
þE
¸	
»G
×	
þE
×	
Î
×	“
×	—
×	
ëG
×	
ËD
×	
ÔY
×	±
×	
áD
¸	


á	
þE
á	
Î
á	“
á	—
¸	
ÀH
¸	

ç	¥
¸	

é	
Î
é	“
é	—
šFuseÁ
í	¥
í	
ËD
š

ð	¥
ð	×
š
ó	

ô	¥
ó	
´E
ö	¥
ó	
ìE
ø	
þE
ø	¥
ø	
ËD
ó	
¼F
ü	
þE
ü	¥
ü	
ËD
ô	
‰G
€

þE
ô	
 G
‚

þE
ó	
»G
„

þE
„
¥
„

ëG
„

ËD
ó	


‰

þE
‰
¥
ó	
ÀH
ó	

�
¥
ó	

�
¥
«MapÁ
‘

Î
‘
—
‘

ËD
‘
±
«
–


—

Î
—
—
–

´E
š

Î
š
—
–

ìE
�

þE
�

Î
�
—
�

ËD
�
±
–

¼F
£

þE
£

Î
£
—
£

ËD
£
±
—

‰G
©

þE
—

 G
«

þE
–

»G
­

þE
­

Î
­
—
­

ëG
­

ËD
­
±
–



´

þE
´

Î
´
—
–

ÀH
–


¹
¥
–


»

Î
»
—
ÅMapWhileÁ
¾

Î
¾
—
¾

ËD
¾
±
Å
Ã


Ä

Î
Ä
—
Ã

´E
Ç

Î
Ç
—
Ã

ìE
Ê

þE
Ê

Î
Ê
—
Ê

ËD
Ê
±
Ã

¼F
Ð

þE
Ð

Î
Ð
—
Ð

ËD
Ð
±
Ä

‰G
Ö

þE
Ä

 G
Ø

þE
Ã

»G
Ú

þE
Ú

Î
Ú
—
Ú

ëG
Ú

ËD
Ú
±
Ã



á

þE
á

Î
á
—
Ã

ÀH
Ã


æ
¥
Ã


è

Î
è
—
ÞMergeÁ
ë
¥
ë
¦
ë
¬
ë
­
ë
a_firstÁ
Þ
ñ


ò
¥
ò
¦
ñ

´E
õ
¥
õ
¦
ñ

ìE
ø

þE
ø
¥
ø
¦
ø
¬
ø
­
ø

±e
ñ

¼F
ÿ

þE
ÿ
¥
ÿ
¦
ÿ
¬
ÿ
­
ÿ

±e
ò

‰G
†
þE
ò

 G
ˆ
þE
ñ

»G
Š
þE
Š¥
Š¦
Š
ëG
Š¬
Š­
Š
±e
ñ



’
þE
’¥
’¦
ñ

ÀH
ñ


—¥
ñ


™¥
™¦
ôNextÁ
œ
Å
œ
Î
œ
ËD
œ
áD
ô

¡
Å
¡
Î
¡×
ô
¥

¦
Å
¦
Î
¥
´E
©
Å
©
Î
¥
ìE
¬
þE
¬
Å
¬
Î
¬
ËD
¬
áD
¥
¼F
²
þE
²
Å
²
Î
²
ËD
²
áD
¦
‰G
¸
þE
¦
 G
º
þE
¥
»G
¼
þE
¼
Å
¼
Î
¼
ëG
¼
ËD
¼
áD
¥


Ã
þE
Ã
Å
Ã
Î
¥
ÀH
¥

È¥
¥

Ê
Å
Ê
Î
†SkipÁ
Í
Î
Í
ËD
Í	remainingÁ
†
Ñ

Ò
Î
Ñ
´E
Ô
Î
Ñ
ìE
Ö
þE
Ö
Î
Ö
ËD
Ö
£k
Ñ
¼F
Û
þE
Û
Î
Û
ËD
Û
£k
Ò
‰G
à
þE
Ò
 G
â
þE
Ñ
»G
ä
þE
ä
Î
ä
ëG
ä
ËD
ä
£k
Ñ


ê
þE
ê
Î
Ñ
ÀH
Ñ

î¥
Ñ

ð
Î
œ	SkipWhileÁ
ò
Î
ò—
ò
ËD
ò	predicateÁ
œ
÷

ø
Î
ø—
÷
´E
û
Î
û—
÷
ìE
þ
þE
þ
Î
þ—
þ
ËD
þ
Øm
÷
¼F
„
þE
„
Î
„—
„
ËD
„
Øm
ø
‰G
Š
þE
ø
 G
Œ
þE
÷
»G
Ž
þE
Ž
Î
Ž—
Ž
ëG
Ž
ËD
Ž
Øm
÷


•
þE
•
Î
•—
÷
ÀH
÷

š¥
÷

œ
Î
œ—
´TakeÁ
Ÿ
Î
Ÿ
ËD
Ÿ
£k
´
£

¤
Î
£
´E
¦
Î
£
ìE
¨
þE
¨
Î
¨
ËD
¨
£k
£
¼F
­
þE
­
Î
­
ËD
­
£k
¤
‰G
²
þE
¤
 G
´
þE
£
»G
¶
þE
¶
Î
¶
ëG
¶
ËD
¶
£k
£


¼
þE
¼
Î
£
ÀH
£

À¥
£

Â
Î
Ê	TakeWhileÁ
Ä
Î
Ä—
Ä
ËD
Ä
Øm
ÄdoneÁ
Ê
Ê

Ë
Î
Ë—
Ê
´E
Î
Î
Î—
Ê
ìE
Ñ
þE
Ñ
Î
Ñ—
Ñ
ËD
Ñ
Øm
Ñ
ìr
Ê
¼F
Ø
þE
Ø
Î
Ø—
Ø
ËD
Ø
Øm
Ø
ìr
Ë
‰G
ß
þE
Ë
 G
á
þE
Ê
»G
ã
þE
ã
Î
ã—
ã
ëG
ã
ËD
ã
Øm
ã
ìr
Ê


ë
þE
ë
Î
ë—
Ê
ÀH
Ê

ð¥
Ê

ò
Î
ò—
ãThenÁ
õ
Î
õ
Ÿ.
õ—
õ
ËD
õfutureÁ
õ±
ã
ü

ý
Î
ý
Ÿ.
ý—
ü
´E
�

Î
�

Ÿ.
�
—
ü
ìE
…

þE
…

Î
…

Ÿ.
…
—
…

ËD
…

ïu
…
±
ü
¼F
�

þE
�

Î
�

Ÿ.
�
—
�

ËD
�

ïu
�
±
ý
‰G
•

þE
ý
 G
—

þE
ü
»G
™

þE
™

Î
™

Ÿ.
™
—
™

ëG
™

ËD
™

ïu
™
±
ü


¢

þE
¢

Î
¢

Ÿ.
¢
—
ü
ÀH
ü

¨
¥
ü

ª

Î
ª

Ÿ.
ª
—
ÿTryNextÁ
®

Å
®

Î
®

à@
®

áD
ÿ

³

Å
³

Î
³
×
ÿ
·


¸

Å
¸

Î
·

´E
»

Å
»

Î
·

ìE
¾

þE
¾

Å
¾

Î
¾

à@
¾

áD
·

¼F
Ä

þE
Ä

Å
Ä

Î
Ä

à@
Ä

áD
¸

‰G
Ê

þE
¸

 G
Ì

þE
·

»G
Î

þE
Î

Å
Î

Î
Î

ëG
Î

à@
Î

áD
·



Õ

þE
Õ

Å
Õ

Î
·

ÀH
·


Ú
¥
·


Ü

Å
Ü

Î
”PeekableÁ
ß
¥
ß

ó0
ß

ËD
”
ã


ä
¥
ã

´E
æ
¥
ã

ìE
è

þE
è
¥
è

ó0
è

ËD
ã

¼F
í

þE
í
¥
í

ó0
í

ËD
ä

‰G
ò

þE
ä

 G
ô

þE
ã

»G
ö

þE
ö
¥
ö

ëG
ö

ó0
ö

ËD
ã



ü

þE
ü
¥
ã

ÀH
ã


€¥
ã


‚¥
B
ê3
„
„

„
„
„
„
„
„
„
„	
„

„
„
„

„

“¤
“æ	
„


–¤
–›

–
ö
–
†
štwice_plus_oneÁ
„

Ͼ	
„

ž×
„

„

¡÷
B
ù3
£
£

£
£
£
£
£
£
£
£	
£

£

¯¤
¯æ	
£


²¤
²›

²
ö
²
†
B
B
B
B
B
B
’4
¼
¼

¼
¼
¼
¼
¼
¼
¼
¼	
¼

¼
¼
’4
É¥
¼

Ë¥
Ëget_refÁ
Ëget_mutÁ
Ë
Ç
¼


Ð¥
Л

Ð
ö
¼is_zeroÁ
B
B
B
B
¢4
Ø
Ø

Ø
Ø
Ø
Ø
Ø
Ø
Ø
Ø	
Ø

Ø
Ø
Ø

æ¤
ææ	
æinto_remainderÁ
Ø


ê¤
ê›

ê
ö
ê
†
î	
B
„ElapsedÁ
ñ

ñˆ
„

ô×
„

„

÷�
„
	
ùÖ
Ú
Ú
Ú
Ú


éEmptyÁ
�

�¥
�ˆ
é

…¥
…×
€IterÁ
ˆš
ˆù
ˆ	yield_amtÁ
€

Œš
Œ×
’OnceÁ
�¥
�ù
’

’¥
’×
§´

•

•¥
•ˆ
§

™¥
™×
¾	StreamMapÁ
œœ
Ϥ
œentriesÁ
¾

 œ
 §
 ×
ƒFastRandÁ
¤oneÁ
¤twoÁ
ƒ


§×
‘
THREAD_RNGÁ
©__rust_std_internal_init_fnÁ
©
«	
¬__RUST_STD_INTERNAL_VALÁ
«	

®
݇

”StreamNotifyCloseÁ
°¤
°
à@
”
³

´¤
³
´E
¶¤
³
ìE
¸
þE
¸¤
¸
à@
³
¼F
¼
þE
¼¤
¼
à@
´
‰G
À
þE
´
 G
Â
þE
³
»G
Ä
þE
Ĥ
Ä
ëG
Ä
à@
³


É
þE
ɤ
³
ÀH
³

Í¥
³

Ϥ
Ø
ChunksTimeoutÁ
Ѥ
Ñ
ËD
ÑdeadlineÁ
ÑdurationÁ
ÑitemsÁ
ÑcapÁ
Ø

ؤ
Ø×
Ø
Û

ܤ
Û
´E
Þ¤
Û
ìE
à
þE
à¤
à
ËD
à
»Š

à
ËŠ

à
ÛŠ

à
èŠ

Û
¼F
è
þE
è¤
è
ËD
è
»Š

è
ËŠ

è
ÛŠ

è
èŠ

Ü
‰G
ð
þE
Ü
 G
ò
þE
Û
»G
ô
þE
ô¤
ô
ëG
ô
ËD
ô
»Š

ô
ËŠ

ô
ÛŠ

ô
èŠ

Û


ý
þE
ý¤
Û
ÀH
Û

�¥
Û

ƒ¤
¼ThrottleÁ
…¥
…delayÁ
…
ËŠ

…has_delayedÁ
…
ËD
¼

‹¥
‹×
¼
Ž

�¥
Ž
´E
‘¥
Ž
ìE
“
þE
“¥
“
ï�

“
ËŠ

“
…Ž

“
ËD
Ž
¼F
š
þE
š¥
š
ï�

š
ËŠ

š
…Ž

š
ËD
�
‰G
¡
þE
�
 G
£
þE
Ž
»G
¥
þE
¥¥
¥
ëG
¥
ï�

¥
ËŠ

¥
…Ž

¥
ËD
Ž


­
þE
­¥
Ž
ÀH
Ž

±¥
Ž

³¥
£TimeoutRepeatingÁ
µ¤
µ
ËD
µ
ÂA
£

¹¤
¹×
£
¼

½¤
¼
´E
¿¤
¼
ìE
Á
þE
Á¤
Á
ËD
Á
ÂA
¼
¼F
Æ
þE
Ƥ
Æ
ËD
Æ
ÂA
½
‰G
Ë
þE
½
 G
Í
þE
¼
»G
Ï
þE
Ϥ
Ï
ëG
Ï
ËD
Ï
ÂA
¼


Õ
þE
Õ¤
¼
ÀH
¼

Ù¥
¼

Û¤
„TimeoutÁ
ݤ
Ý
ËD
Ý
»Š

Ý
ËŠ

Ý
poll_deadlineÁ
„


ã¤
ã×
„
æ

ç¤
æ
´E
é¤
æ
ìE
ë
þE
ë¤
ë
ËD
ë
»Š

ë
ËŠ

ë
Ú“

æ
¼F
ò
þE
ò¤
ò
ËD
ò
»Š

ò
ËŠ

ò
Ú“

ç
‰G
ù
þE
ç
 G
û
þE
æ
»G
ý
þE
ý¤
ý
ëG
ý
ËD
ý
»Š

ý
ËŠ

ý
Ú“

æ


…
þE
…¤
æ
ÀH
æ

‰¥
æ

‹¤













"

2

6

6


6

7

:

=

T

X

X


X

i

m

m


m

€


€



€


‚


›


›



›


¡


¢


©


ª


±


²


¹


º


Å


Æ


Ì


Í


ß


ß



ß


ä


è


è



è


é


÷


÷



÷


�

�


�

‚

˜

˜


˜

¨

¨


¨

©

¶

¶


¶

À

À


À

Ã

Ð

Ð


Ð

Ú

Ú


Ú

Ü

î

î


î

ï

ð

ð


ð

ð

�

„

„


„

‘

‘


‘

˜

˜


˜

™

¨

¨


¨

­

±

±


±

²

¿

¿


¿

Æ

Æ


Æ

È

Õ

Õ


Õ

Ú

Þ

Þ


Þ

á

ð

ð


ð

û

û


û

ü

�

’

’


’

 

¦

¦


¦

©

ª

¸

¿

Â

Ä

Æ

û

û


û

ü

�

�


�

Ž

¢

¢


¢

£

¹

¹


¹

º

Ë

Í

Ñ

Ô

×

Ú

Û

Ü

Ý

Þ

ß

ß


á

á


æ

æ


æ

î

î


ò

ò


ò

ò

÷

÷


÷

ø

�

�

�

¢

¢


¢

¤

­

­


­

³

³


³

Â

Â


Â

Ã

Å

Ç

Ì

Ì


Ì

Ü

Ü


Ü

Þ

à

å

å


å

ñ

ñ


ñ

÷

¯

¯


¯

µ

ë

›

›


›

¡

Ú

‡	

·	

·	


·	

½	

ò	

ò	


ò	

ö	

š


Ç


õ


¤

¤


¤

©

Ô

û

¦

Î

�


¶


¶



¶


»


æ


™

™


™

š

Ÿ

Ÿ


Ÿ

µ

µ


µ

¶

Í

Î

Ó

Ó


Ó

é

í

í


í

î

õ

õ


õ

ø

ø


ú

‡

‡


‡

Ž

Ž


Ž

”

”


”

›

›


›

£

£


£

¨

¨


¨

¶

Ú

Ú


Ú

Þ

�

�


�

‘

»

»


»

¿

å

å


å

é

¡8
Ì8
Î8
Ò8
Õ8
Ø8
ï8
ï8
�ۉʑ
È
ø¥	æ	Œ
¸
å
–Çí™¿ï§
Ù
ÿ
ˆØ°€¨Ì¿c

¨
¨
Â@

ª
à@

ÙÞNµ�ÊóB

¥

&E

¼¤


à
¼¤

ŒM
ŒMReceiverÁ

ŽMchanÁ
ìL
‡G#tl4'

é¤


ã
¼¤

„¥


é
¼¤

„¥


¿c

®
®
€A

°
à@
'

¬p<XZ—©

é¤


&E

ç¥


à
ç¥

¬P
¬PUnboundedReceiverÁ

®P
Ÿ¤

”P
´9ˆeŠ5Ê

é¤


ã
ç¥

­¦


é
ç¥

­¦


¿c

É
É
ÊB

Ê
à@
´
žËŽ–X

&E

–§


à
–§

Ñe
ÑeIntervalÁ
Òe
ï�

‚d
ÓeperiodÁ
‚d
Ôemissed_tick_behaviorÁ
‚d
‰=ù߯ÐÚ

ã
–§

Ù§


¿c

â
â
ùC

ã
à@
Í
‹l¸1}¹#=

&E

ب


à
ب

Ì

Ì

Í
ReadDirÁ

Î
ˆ
ç
õ°XïçT›í

ã
ب

›©


¿c

æ
æ
¢D
ê
ËD
E
ë±
E
ì
áD
E
½/سíïã
Å


Î
—

“í


æ
æ
¢D
ê
ËD
E
ë±
E
ì
áD
E
½/سíïã

Å

Î
—

�

é¤


�

ê©


‚Ø

æ
æ
¢D
ê
ËD
E
ë±
E
ì
áD
E
½/سíïã8
³ª

¹ª


¿c

¤
¤
€I
¨
ËD
Z
©±
Z
ª
áD
Z
)p1*ÙŽ¡}
Å
³ª

¹ª


“í


¤
¤
€I
¨
ËD
Z
©±
Z
ª
áD
Z
)p1*ÙŽ¡}

Å
�«

–«


Û

é¤


Û

‘¬


‚Ø

¤
¤
€I
¨
ËD
Z
©±
Z
ª
áD
Z
)p1*ÙŽ¡}8
³ª

¹ª


“í


â
â
æL
å¬
o
æ­
o
	—‰`Õµ

¥
¦

‰

é¤


‰

â
â
æL
å¬
o
æ­
o
	—‰`Õµ
é¤


¦

&E

‡¯


¿c

�
�
ÅO
“
ËD
„

”
ôO
„

•
†P
„

–
áD
„

wNrx AÉÞ
é¤

ï

”

“í


�
�
ÅO
“
ËD
„

”
ôO
„

•
†P
„

–
áD
„

wNrx AÉÞ
é®

ï®

”

Ê

é¤


Ê

Ú¯


‚Ø

�
�
ÅO
“
ËD
„

”
ôO
„

•
†P
„

–
áD
„

wNrx AÉÞ
é¤

ï


ï



é¤
&FÊ


‘




È




‘

úH
úHß


ûHÁ
‘4
Ý­f‰úM÷
é¤


È

в

é¤


‘

ªB
ªBö

­BbufÁ
÷<
®B‘
÷<
9)
-ÜnL
é¤

çE
çE

èEGlobalÁ
¿±‡§í#
é¤


È

˜³

é¤


‘

�
�
žBoxÁ
¡ˆ
ˆ
¢‰
ˆ
l}.xÏ

é¤

Ù³

é¤


È

Ÿ´

é¤


‘

Ö¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â

ï

–
Ö¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â

é¤

Õµ


È

ĵ

Ûµ


“í


Ñ
Ñ
ÝS
Ô
ËD
Ó

Õ±
Ó


ȸÊ"àM!
³ª

¹ª


ø

é¤


ø

Ñ
Ñ
ÝS
Ô
ËD
Ó

Õ±
Ó


ȸÊ"àM!

Î

—

¿c

œ·


&E

œ·


“í


þ
þ
¾V
�	
ËD
ë

‚	±
ë

SŽ2€~ž_
³ª

¹ª


¥	

é¤


¥	

þ
þ
¾V
�	
ËD
ë

‚	±
ë

SŽ2€~ž_
Ö·

Ü·


¿c

Ó¸


&E

Ó¸


¿c

«	
«	
¢Y
¯	
ËD
„
°	
ÔY
„
±	±
„
²	
áD
„
¿>
•S‹
Ö·


“
¹ª


“í


«	
«	
¢Y
¯	
ËD
„
°	
ÔY
„
±	±
„
²	
áD
„
¿>
•S‹
³ª

“
–«


æ	

é¤


æ	

±¹


‚Ø

±¹


¿c

í	
í	
¯]

ï	
ËD
š
Ÿéû+Ó² ¶

é¤


“í


í	
í	
¯]

ï	
ËD
š
Ÿéû+Ó² ¶

é®


Œ


é¤


Œ


¢»


&E

¢»


“í


‘

‘

Ã_
”

ËD
«
•
±
«
Ö¯K‰´Êu
³ª

¹ª


¸


é¤


¸


‘

‘

Ã_
”

ËD
«
•
±
«
Ö¯K‰´Êu
Ö·

Ü·


¿c

Š½


&E

Š½


“í


¾

¾

¡b
Á

ËD
Å
Â
±
Å
¢«/à;ªz
³ª

¹ª


å


é¤


å


¾

¾

¡b
Á

ËD
Å
Â
±
Å
¢«/à;ªz
Ö·

Ü·


¿c

½¾


&E

½¾


“í


ë

ë

„e
î
¬
Þ
ï
­
Þ
ð

±e
Þ
Õõb˜PI‹¦
é®

ï®


–

é¤


–

ë

ë

„e
î
¬
Þ
ï
­
Þ
ð

±e
Þ
Õõb˜PI‹¦
é¤

ï


&E

ü¿


¿c

œ
œ
‹h
Ÿ
ËD
ô
 
áD
ô
èΟ6ú`
Å
³ª


“í


œ
œ
‹h
Ÿ
ËD
ô
 
áD
ô
èΟ6ú`

Å
�«


Ç

é¤


Ç

ÛÀ


‚Ø

œ
œ
‹h
Ÿ
ËD
ô
 
áD
ô
èΟ6ú`8
³ª


“í


Í
Í
‡k
Ï
ËD
†
Ð
£k
†
xæ_6ÂÈå

³ª


í

é¤


í

Í
Í
‡k
Ï
ËD
†
Ð
£k
†
xæ_6ÂÈå

Ö·


¿c

¤Ã


&E

¤Ã


“í


ò
ò
¯m
õ
ËD
œ
ö
Øm
œ
/[S®oŠˆ
³ª

¹ª


™

é¤


™

ò
ò
¯m
õ
ËD
œ
ö
Øm
œ
/[S®oŠˆ
Ö·

Ü·


¿c

ÓÄ


&E

ÓÄ


“í


Ÿ
Ÿ
œp
¡
ËD
´
¢
£k
´
70´%b»

³ª


¿

é¤


¿

Ÿ
Ÿ
œp
¡
ËD
´
¢
£k
´
70´%b»

Ö·


¿c

‚Æ


&E

‚Æ


“í


Ä
Ä
»r
Ç
ËD
Ê
È
Øm
Ê
É
ìr
Ê
ÆtãL¾jÖC
³ª

¹ª


ï

é¤


ï

Ä
Ä
»r
Ç
ËD
Ê
È
Øm
Ê
É
ìr
Ê
ÆtãL¾jÖC
Ö·

Ü·


¿c

½Ç


&E

½Ç


“í


õ
õ
Ãu
ù
ËD
ã
ú
ïu
ã
û±
ã
L²Îß'Úí
³ª


Ÿ.
–«


§


é¤


§


õ
õ
Ãu
ù
ËD
ã
ú
ïu
ã
û±
ã
L²Îß'Úí
Ö·



Ÿ.
¹ª


¿c

ŽÉ


&E

õ
õ
Ãu
ù
ËD
ã
ú
ïu
ã
û±
ã
L²Îß'Úí
Ö·

òÈ

Ü·


¿c

®

®

ˆy
±

à@
ÿ
²

áD
ÿ
HQˆ{žá
Å
³ª


“í


®

®

ˆy
±

à@
ÿ
²

áD
ÿ
HQˆ{žá

Å
�«


Ù


é¤


Ù


ÌÊ


‚Ø

®

®

ˆy
±

à@
ÿ
²

áD
ÿ
HQˆ{žá8

Î

“í


ß

ß

‡|
á

ó0
”
â

ËD
”
×fE* }Ÿ

é®


ÿ


é¤


ÿ


ß

ß

‡|
á

ó0
”
â

ËD
”
×fE* }Ÿ

é¤


&E

—Í


¿c

Ý
Ý
©“

ß
ËD
„
à
»Š

„
á
ËŠ

„
â
Ú“

„
’¤#bO¼‹

¤

“í


Ý
Ý
©“

ß
ËD
„
à
»Š

„
á
ËŠ

„
â
Ú“

„
’¤#bO¼‹


¤

ˆ

é¤


ˆ

æÍ


¿c

ñ
ñ
ò
Þƒ


óˆ
„
ë.Ü#mx

Ðì


ÃÏ


µß

ÃÏ

ÃÏ


™

ÃÏ


&E

æÍ


Äc

ÃÏ


¾

ÃÏ


é

ß

ßErrorÁ


à…

¬

ÑøÿËO Ÿ
ÃÏ


¿c

µ
µ
é�

·
ËD
£
¸
ÂA
£
¡WÙ½pZÚ

¼Î


“í


µ
µ
é�

·
ËD
£
¸
ÂA
£
¡WÙ½pZÚ

 Ï


Ø

é¤


Ø

‚Ñ


&E

‚Ñ


¿c

…
…
�

‡
ï�

¼
ˆ
ËŠ

¼
‰
…Ž

¼
Š
ËD
¼
÷æ|7ðÚ‰—

é¤


“í


…
…
�

‡
ï�

¼
ˆ
ËŠ

¼
‰
…Ž

¼
Š
ËD
¼
÷æ|7ðÚ‰—

é®


°

é¤


°

¯Ò


&E

¯Ò


¿c

Ñ
Ñ
–Š

Ó
ËD
Ø
Ô
»Š

Ø
Õ
ËŠ

Ø
Ö
ÛŠ

Ø
×
èŠ

Ø
0ôœ(¥YC

¼Î


“í


Ñ
Ñ
–Š

Ó
ËD
Ø
Ô
»Š

Ø
Õ
ËŠ

Ø
Ö
ÛŠ

Ø
×
èŠ

Ø
0ôœ(¥YC

 Ï


€

é¤


€

’Ô


&E

’Ô


¨

Ö·


¿c

�
�
‚
„


„ˆ
é
%8M8IùJ£

é¤


“í


šÖ


Ìì


šÖ

� 

šÖ

&E

šÖ


¿c

ˆ
ˆ
ù„

Šù
€
‹
•…

€
‹‘v´§ @n

š

“í


…×


&E

…×


¿c

�
�
»…


‘ù
’
綦Þ~ÇÛ

é¤


“í


�
�
»…


‘ù
’
綦Þ~ÇÛ

Á×


&E

ä×


¿c

•
•
–´


˜ˆ
§
wéðËh�

é¤


“í


ãØ


Ìì


ãØ

� 

ãØ

&E

ãØ


¿c

œ
œ
ž†


Ÿ
¿†

¾
'ö,_ÿíî
œ

§

³

ÍÙ


&E

ÍÙ


ÃL
ÍÙ

ýÙ
ƒÚ


ÐL
ÍÙ

©Ú


¿c

¤
¤
ë†

¥
û†

ƒ
¦
†‡

ƒ
ß¾¶ôà
!

“í


°
°
Šˆ


²
à@
”
¶Û.1v

 Ï


Ì

é¤


Ì

°
°
Šˆ


²
à@
”
¶Û.1v

¼Î


&E

ÒÛ


«
¨±
®Ë
Éä
âí
æ«
¤—
�Ü

Ñô

þ³	
«	ð	
í	³
‘
Í
¾
¡
œ�
Í¥
ò½
ŸÒ
Äì
õ³

®
ã
Ýô
ñ¹
µ‹
…Ø
Ñ…
�Œ
ˆ’
�™
• 
Ϥ
¤
¨3
®À
ÉÚ
â|
âä

Ñü

þ¥
í	»
‘
Õ
¾
ê
ë
•
Í­
òÃ
ŸÚ
Äö
õ£
ß
–
ݲ
µÐ
…ê
Ñø
�Š
ˆŸ
�¶
•ó
œŸ
°
¨8
®Ä
ÉÝ
â 
¨;
®Æ
Éß
â#
¨>
®¡

ߘ
æÖ
¤…
âÅ
�ô
Ñ¡	
þá	
«	‰

í	´

‘
á

¾
’
ë
Ã
ϐ
Í•
ò¼
Ÿë
Ä¢

õÕ

®
ü

ß
…
ÝÕ
µ­
…ý
Ñð
�†
ˆ›
�®
•É
°ž 
æT
æi
¤—

�“
«	�
œ�
®
ÜÞ
¤ŠŒ
âËÍ
��


£

úH«

ªB³

�»

Ö¿ž


¥

úH­

ªBµ

�¿

Ö¿ùû
Ѧ	¨	
þç	é	
«	�
�

í	¹
»

‘
æ
è

¾
—™
ë
ÈÊ
œîð
Íšœ
òÀÂ
Ÿðò
Ä¨
ª

õÚ
Ü

®
€‚
ß
‰‹
Ýö
ñ÷
ñù
ñž
ñ 
ñÙÛ
µ±³
…�ƒ
ÑÔò
�°
•ô
�²
•ç
ϝ
œþ
œÍÏ
°¿cÑ&EÙ
àº
ãé“í
�Ä
‚Ø
Û(‰
Ê
‘

È
"ø"¥	
æ	
Œ

¸

å

–
Ç
í
™
¿
ï
§

Ù

ÿ

ˆ
Ðì


µß

™
Äc
¾
Ø°
€
¨

Ìì
� ³
ÃL
ÐL
Ì

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Á

_Áü”«



¢
é¤


“Ø
“Ø
”ØÎ


•Øˆ
ä
o
³΢½

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

¡²


—Í


®

»



	HÄÕ
Ž


Ž
L´
Ž

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

¡²

d¥


	4ª
Ž

•ê

Û


¡²
DÌ	Û¼


£é


üž›


$þ

Ž

\þ
$ƒ

©

—Í

3
4ƒ
(ÆŠ
	

ˆØ

œ
œ
‹h
Ÿ
ËD
ô
 
áD
ô
èΟ6ú`
—Í


„
a
ˆÇþ


¦ì



†	

¦ì

ž£

öX

¦ì


	¸
Á
Å

Ò×

„Ø

¦ì

ê
Š
ø
ü





	
 
	ϯ


Þè
7


C
å

È

•ê
Lò

Ž



•ê


,

Ž
@

•ê
L�

Ž


•ê

”�
4§

©T

¡²


E
D§¥

Ž
¹

•ê

Ž

¿	œØ

Þè





&
l

x


€


Ž
£	©


¾	Ä


ó

¢èøÈ”«

ü¾ 

ø

ÿ



"


%

"	
ÆŽ

"


1
(

�
Ⱦ

‚
‹
”
0
§¯¶½Ä
Í

×

®
˜è
ê

ý

ò

ù
#

˜è


�

�
k
�
wakerÁ
¸�

�
local_wakerÁ
¸�

�
extÁ
¸�

�
_markerÁ
¸�

Ò�
_marker2Á
¸�

f'EwÚ]¾å

±¬é
LÕ
i£é
`
£é
Ñ
•ê
Œþ
¦ì
Þ
¦ì

Ž
4
¦ì
”

	
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

•ê
W
„¾
„¾PinÁ

†¾‰
˜X
$]È=„kt•

¿í
”
¿í
�
¿í
¦
§ô
J
§ô
S
§ô
Á
É•ê
m
t
§ô
â
ê
•ê
E
Ó
Û
ã
ë
ó
û
Þè
:
B
þ
M$Ú

Ž
°



Ž
itÁû



¦ì
�2«



¼


Ê	œØ


à

ë


¢ú








œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

g	
˜è
p	
§ô
y	�	


Ž
צì
)


û

”sw°
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

Þè


„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•

–è
M

§ô
V

	£é
û
¦ì
e
¦ì
š
Ÿö
w
íö
€
¿í
‰
§ô
’
š•ê
>
§ô
¬
€ø

Þè
É

Ñ

–è
Ú

Ž
ã

Ž
ì

Ž
õ

Ž
þ

Ž

Ž

Ž
þ
$×
Ž
†

Ž

ƒø
ê	û
ò

¦ì
�	€

óë
¬	Ÿì
‡	¹í
Ž	íí
•	
•ê
<úï
È

Ž
¦ì
U	


û

,ž¢Û	¬é
:¦ì
Œ	


û

cÕÙ


_Á

_Á

_Á

_Á
\ÿ

	• 

é¤
”ù	�

é¤



Š

�
ö
üÏ>
šÖ
Dê
• 
• 

– PhantomDataÁ
Fu
\»Ÿ

é¤
›Q


\ý

	• 

é¤
¤õ	•

é¤



ˆ

‹
´
üÇD
ãØ
Tä
¼�j 

ü™‹
J


ð
ýÙ

ƒÚ


¥è



ÍÙ

ªB
ªBö

­B
«²

÷<
®B‘
÷<
9)
-ÜnL
ýÙ


ƒÚ
&F
Ù³


‰

–




HÝ׊


²ƒ0ÞâŠ




¸ƒ(ß‚‹


ü«‹
+
	ñ
ýÙ

ƒÚ






�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å



œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã



²ƒ¸ƒ

ü£‹
4<£‹


Ç€


ñ
ýÙ

ƒÚ


¦…
ô†

O


A
(áØ‹



ˆØ

Ê€

Ê€
PollFnÁ

Ì€
±
À€

¡Ab«SÁh

©‡

œ

^
ø⣋
:

ë‡

~
…

ë‡
�¢

öX

ë‡

·


À
Ä
ÑÖ

„Ø

ë‡

éŒ	

÷
û
	





	
Ã
!
	ϯ


7


C
è	
È

ã‹
	ϯ





&
Ý

é
ð
ª


¸

	


/	5



ðPø㙋
J




#


	
‚


�

áÜ‹
â‹
ãâ‹




á
ê
ó
=
#*
3

=

®
•ƒP







 


•ƒ
Š
§ô
“²ƒL׊
¸ƒ4âŠ

,‚‹

ë‡j
뇺
©‡Û
²ƒä
¸ƒí
ü†ö
ë‡>
ú°
©†¹
„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•

‚‰ô
‚‰ý
‚‰
§ô
­
§ô
¶
§ô
!
)Ï
Ö
§ô
A
I
£
«
	þ
¶$ÜŠ


²ƒbufferÁ4



¸ƒlimitÁA


f


Ö�h

î�k


û
|


ë‡�‘N



_


m	ϯ


ƒ

Ž


ð�M
T

[
f
m

¥ú
Í
•ƒÖ
§ô
ßç


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Ù

ÈÚ

ÈÚ

õ—µ

æ
ùî�f�
a

©



®

®£



°
à@

¨
it§ÅLS¶

ÈÚ
áî¢fa
[

"

«

õ—õ—
_Áùïðe



éïðe


Ð

ÈÚ



2
8



ù瑩e

	¬





ú—Ž™

2


õ—	ï¿e

ùïíÔe
ùï‚!­e

	®


‹›
%


õ—	ï›!e

R
	ïÀ$e


ùïÛôe

«

õ—!
$

¬


‹›
ó
®


‹›
¨W

_Á

_Á

”¢	ñ



ò
%
ÃÏ
18
?



φ
	�

é¤




‚
)
šÖ
5¼�=
D




ˆ
	•

é¤




–
)
ãØ
5¼�=
D



BÚ递§¾”À





¸Tå‘

Ø
©1Lñ¨
Ù
Ã5,¬ö
þ
„
,³
�
ÿù$Õˆ
�
ù„
$Û
ˆ
‘
Ã7$ü�
¥
»…
$‚
�
¦
Ä8<©´
¼´
<²
•
½
ž†
Lá
œ
“
Šˆ
Υ
°
¦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Áü® üÐ"
|”
BÚ递§¾”ÀÍ




¸Î‘

Ø
©1Í¨
Ù
Ã5Ìö
þ
„
Ë
�
ÿùÊˆ
�
ù„
É
ˆ
‘
Ã7È�
¥
»…
Ç
�
¦
Ä8Æ´
¼´
Å
•
½
ž†
Ä
œ
“
Šˆ
Ã
°
¦
ˆ ½&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
ŒLš+²
³ã8äD´
¼â8
ø»4½
$Ã8ÓÅ
Èá8âÉ
Ìà8»<ÍÕ7
ŒL×,ñ8÷$ò
€¤‹<˜
 É

¦µ
,§
¨³

,©8÷$ª
&®8÷$¯
´*·
ºÇ
,Ä
ÅÀ
+Ó
Ôé8âÕ
Øè8»<Ùá7
�,ã+÷
ø¤8äDù
�£8
ø»4‚
$ˆ8ÓŠ
�¢8âŽ
‘¡8»<’š7
�,œ,²8÷$³
Á¬ÌDÙ
â�

è÷
,é
êõ

,ë8÷$ì
&ð8÷$ñ
ö*ù
ü‹
,†
‡„
+•
–¬8â—
š«8»<›£7timeÁ4¥+º
»è8äD¼
Äç8
ø»4Å
$Ë8ÓÍ
Ðæ8âÑ
Ôå8»<ÕÝ7
¬Ä4ß,ö8÷$÷
…¬�D�
¦Ñ

¬»
,­
®¹

,¯8÷$°
&´8÷$µ
º*½
ÀÏ
,Ê
ËÈ
+Ù
Úð8âÛ
Þï8»<ßç7ç4é+þ
ÿ¬8äD€
ˆ«8
ø»4‰
$�8Ó‘
”ª8â•
˜©8»<™¡7ç4£,º8÷$»
ɼÔTá
ì›	

ò�
,ó
ôÿ

,õ8÷$ö
&ú8÷$û
€*ƒ
†™	
,�
‘’	
+Ÿ
 ¸8â¡
¤·8»<¥­7
ÔD¯+Æ
Çö8äDÈ
Ðõ8
ø»4Ñ
$×8ÓÙ
Üô8âÝ
àó8»<áé7
ÔDë,„	8÷$…	
“	„¤
ü5
2 Wrappers for Tokio types that implement `Stream`.ÁD¬'´Í
Â@tñ


¨
&
€A¼®

®
A
ÊBtœ

É
È
ùCl„


â
átY
ü7!
 Error types for the wrappers.Á4a
„É

dÍ



¨
ˆ 4&E

§
ùõ
!
„¾

k<6
�


·
$?ϯ


Ž¤
D]
ŒM

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Á,€


�
�¼¤





†



é¤

$‹ü¸$
¥


¾Ï½¼¤
&F&G&HLã$è


é¤
ü÷XLú

Ž
�
�„¾
„¾
ùõ


†¾‰
˜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
ÛÔLà


‘
‘¼¤
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ





ê



é¤

$ëü�0
¥


¾Ï†¼¤
â
ü¸ 4»


’
’¼¤

’„¥




Â



é¤

$Ãüø0
¥!

!
¾Ïý¼¤
"å
"ü¯(4²


“
“¼¤


“„¥



 

¹
 
"

é¤

$¾üû/
¥$

$
¾Ï€¼¤
%ë
%ü±"$´
„¥
¼¤


#

#
%

é¤


ÐÏ$¹äã

”‚
t†


®
ˆ 4	&E
'(§
ùõ
!	
„¾
'
)k<6	
�

'
+·
$?	ϯ
'
,
·¥
Œ]	
¬P
'
-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

é¤

$Õ	ü‚
-	
¥4

4
¾Ï‡
	ç¥
567&F&G&H67L¶
	$»
	
3

3é¤
üÊ
X	LÍ
	

•
–
—„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


•ç¥



–Ì�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

—
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ



ç¥
&F

3

å
	
3
6

é¤

$Û
	

âÙñ
	ü¸-	üÑF	
úÙœ	úü¤;	
ÖÚä	úüìG	D For closed channels, it returns `(receiver.len(), receiver.len())`.ÁL»	


˜
˜ç¥
ýÞ

3

Å	
3
7

é¤

$Æ	üšB	
¥9

9
¾ÏŸ	ç¥
:â
:üã)	4æ	


™
™ç¥

™­¦


8

í	
8
:

é¤

$î	ü¬B	
¥<

<
¾Ï±	ç¥
=å
=üõ1	4ø	


š
šç¥


š­¦



;

ÿ	
;
=

é¤

$„	üÊA	
¥?

?
¾ÏÏ	ç¥
@ë
@ü’+	$•	
­¦
ç¥


>

>
@

é¤


ÐÏ$š	üž'
6t·T»
EZo„
Ó
ë
„š«ÅÞô†œ´Êãÿ”¨Ö„£¼ØFutureÁ4
‚Ø
B
C
ˆ 4,
&E
B
D
¢DLG

æ
B
Y
€ILe

¤
B
n
æL,‹


â
ƒ

ÅO<¹


�
B
Ñ

¸TÂ

‘

B
Ò

ÝS4ì


Ñ
ê

¾VL™

þ
ƒ
¢YT¹

«	
B
™
¯]$Þ

í	
ª
Ã_û

‘

Ä
¡bD£

¾

Ý
„e,È

ë

ó
‹h$ä

œ
B
…
‡k$ƒ

Í
›
¯mL®

ò
³
œp$Ò

Ÿ
É
»rLý

Ä
â
Ãu$¡

õ
þ
ˆy<Ä

®

B
“
‡|Dî

ß

§
©“
<Ü

Ý
·
é�
„„

µ
¸DurationÁD¬

­Ö
B
º
ã¦
D¶

Ñe
B
»
’4Dæ
É
B
Ö
�
Dð

…
B
×
–Š
l¯

Ñ
ð¤
+¤
<5
9

Bæò
ˆ 4&E
EF§
¨ñ4&‚Ø
E
G
PhantomPinnedÁl@
Ӓ

E
H
�ö
•í

E
H
ùõ
^
„¾
E
IreadyÁ,t
¥‚

E
Kk<{
�

E
L·
$„
ϯ
E
Mpin_projectÁ\¡


E
NlϤ¾Ü2£tSTgln]_NPì�
7ü·,
ÅP
ÎQ

—R
PQ
RÎì


³ª
ÀÍì


¹ª
Ìê©
S
¼!#üê3ø
B



ųª

¹ª
ê©


O
O
S
Å
³ª

¹ª


ËD4ü
±�ü†r8›
ÎU

—V
›VU

¹ª




³ª
&F˜"$ó±ù�&E

³ª
4É“í


³ª
,Ò“"
¹ª

‰û¼à ù‹º«
WXƒØ„Ø
Xbd\ÿ4„
T
Tü˜I$›



œ
�
ž„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


œº«



��

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

ž
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã



º«
į

T
ª
T
X8
³ª

¹ª

$ 

âÙ¶tB
H<S
W

B¤°
ˆ 4&E
Z[§
¨ñ4&‚Ø
Z
\
�öl@
Ӓ

Z
]
�ö
•í

Z
]
ùõ
^
„¾
Z
^
æö,t
¥‚

Z
`k<{
�

Z
a·
$„
ϯ
Z
b
¥÷\¡


Z
clµ¤¤Ü2•tSqTgbdSUDFì�
7ü·,
Åe
Îf

—g
gef
 ùÀ±ùÌ‘¬
h
¼üê3ø
B


Šú¹ª
‘¬


d
d
h
Å
³ª

¹ª


ËD4ü
±�ü†r8Ÿ
Îj

—k
j
kŸ�û$ó±ù�¦û4Éµû,ÒÆû¼à ù‹Ù­
lmƒØ„Ø
mFH\ÿ4„
i
iü˜I$›



 
¡
¢„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


 Ù­



¡Ì�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

¢
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã



Ù­
į

i
ª
i
m8
³ª

¹ª

$ 

âÙ¶t`

Lq
,u

Bâç
¯]$

í	
opª
ˆ 4(
&E
oq§
ùõ
@

„¾
o
r
æö,V

¥‚

o
tk<]

�

o
u·
$f
ϯ
o
v
¥÷\ƒ



o
w¼
Žl!
|t5
kTI
\^MO>@ìq
1´Ð
¥y
¦z

yz
¾ÏÕ
Íì


ï
Ø
‡¯
{
üí\
û

B

é¤
ï
‡¯


x
x&E

é¤
4¯
&E

ï
4Â

{
é¤

ï

¬ÿ

­…
üþU
¥}
¦~

}~


ï
&F¡²
tÃ
èˆ†
Ó‰4­
≴¼
¾Ïƒ
‡¯
€
‚
&F&G&H€
‚
!#FHLÚ
$ß

|
|¡²
üôQ
L÷



£
¤
¥„¾
„¾
ùõ


†¾‰
˜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.ÁTÔ‘

¥’


‘
’


Îì


üÊ5È

¢•
é®
ÌãÍì


é®
ß‘


š•>­•/š•J­•;-/ü�	`¥”

¦•


”
•

¾Ï†	èˆ‰	Ó‰4¾	‘

ï

¡²
œÍ	À±
–

/146üè	Dö	
B

é¤
˱


“

“

–

é¤

ï


ËD4ú	ü½k¥˜

¦™


˜
™

¾ÏÂèˆÅÓ‰4…
Í–œ”
˱
š
›
ƒØ„Ø
›
469;\¯
4´

—

—
ï
üÅ
B$È



§
¨
©„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


§À±



¨Ì�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

©
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ï


—

Û

—

›

é¤

ï

$Ñ


âÙç
\–,œÔ¦üÅ&Ÿ
 
¡
¢
Ê
Ë
Ì
Í
¢
 
¡
¼ò”÷
ž

ž
ü•HT˜Î

Î


Ï

Á
¢ �h»³�ß

ž

ž

 

£
_lowerÁ4¸
_upperÁ4ÇüæG4é

ªÜœ
ª


ž

’
ž

¡

ð
_collectionÁ\…
_itemÁ,›üÈ6DË

«Üœ
«


ž

ö
ž

¢

Ô

š�\éü…,
¥¤


¤
¾ÏŠà
é¤

T�в
ü¶8
¥¦


¦
¾Ï»¾ŸT¾в
§
¨
©
ª
Ê
Ë
Ì
Í
ª
¨
©
8:¼õ”ú
¥


¥
в
üœRTŸ
Üœ�ßв


¥


¥

¨


é¤

ª

§œ4¿

µœ4Îü’H4•

¬Üœ
¬в

é¤


¥


½
¥

©


é¤

œ

ôOT±
÷$Êü¡CD¤


­Üœ
­в

в


¥


Î
¥

ª


é¤

­

ôOTÂüŽ 
¥¬


¬

¾Ï“˜³

ü³,
¥®


®

¾Ï¸˜³
¯
°
±
²
Ê
Ë
Ì
Í
±
²
°
02¼æ”ë
­


­
˜³
ü�QT�Üœ�ߘ³


­


­

°


é¤

›
lowerÁ,°

µœ4¾üŽH4‘


®Üœ
®˜³

é¤


­


¹
­

±


é¤

˜

ôOT­
÷$Æü�CD“


¯Üœ
¯˜³

˜³


­


½
­

²


é¤

œ

ôOT±üý"
¥´


´

¾Ï‚Ÿ´

ü¤.
¥¶


¶

¾Ï©Ÿ´
·
¸
¹
º
Ê
Ë
Ì
Í
¹
¸
º
02¼Ù”Þ
µ


µ
˜³
ü€PTƒÜœ�ߘ³


µ


µ

¸


é¤

Ž

�¤,£
upperÁ,±ü¸H4»


°Üœ
°˜³

é¤


µ


ã
µ

¹


é¤

Â

ôOT×
÷$ðüè EDë 


±Üœ
±˜³

Ÿ´


µ


•!
µ

º


é¤

ô 

ôOT‰!ü¯"N¥¼

¦½


–¾

½

¾
¼
¾Ï´"èˆ·"Íì


Õµ
º"‘

ï

é¤
lð"ƒµ
57:<68ü‚#_¥À

¦Á


–Â

Â
À
Á

¾Ï‡#èˆŠ#©«�#º«lÓ#ƒµ
Ã
Ä
Å
Æ
Ê
Ë
Ì
Í
Å
Ä
Æ
HJMORT¼è#”í#
¿

¿
Ö¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â


ï

é¤
Ê

Õµ
ü©$‰
T¬$

Üœ�ß¾­

¿

¿

Ä

é¤

ï

Õµ

À$

�¤,Ý$

þ§,ó$üú%„
4ý%




²Üœ
²
ĵ

Ûµ
Ê

Ûµ


¿

¶&
¿

Å

é¤

ï

Õµ

�&

ôOTª&
÷$Ý&üï)[Dò)




³Üœ
³»¯
ĵ


¿

œ*
¿

Æ

é¤

ï

Õµ

û)

ôOT�*¬ï,4þ,
È
Î
Ï
Üž-
4‘-t¨-È

¥É


É

È

š•üž-�Á•·-È


š•"š•(Ê
Ë
Ì
Í
Ê
Ë
Ì
Í
Íì



¢•
é®
Ê
ÄÖ.—²Í
Ë
Ì
ce¼Ö.”Û.
È


È
üž/‘
T¡/

Üœ�ߟ²

È


È

Ë

¢•
é®

åD¹/

�¤,Ù/

þ§,ó/üÌ1Z4Ï1



´Üœ
´Ÿ²
é®


È


ö1
È

Ì

¢•
é®

åDÖ1

ôOTê1
÷$•2üâ2SDå2



µÜœ
µŸ²
¢•

È


Ž3
È

Í

¢•
é®

åDî2

ôOT‚3œí3Dø3Üœ¢ �h»³


Ï
-)
Î

Î
Üœ<¯

!‚!q!t!TÐ

4Ô


BÑÖ
ˆ 4&E
Ó
Ô
§× `
Ó

Õ

ùõ
2
„¾
Ó

Ö

æö,H
¥‚

Ó

Ø
k<O
�

Ó

Ù
·
$Xϯ
Ó

Ú

¥÷\u

Ó

Û
l–L„t'tT;ceRTACìc2üìB
ÎÝ

—Þ


Ý
Þ

Íì


Ö·
ñÍì


Ü·
õ¿c

Ö·
T£œ·
ß
Àc
ß
4602üµ8¸
¶
·
¸
¶œ·


· c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


¸
Ö¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â


ŸÈ
ŸÈ

 È
ÎÏ

O˜éBL

Ü

¼
Ü

ß

Ö·

Ü·

$½
±ÃÌÛ
Îá

—â


â

á
Ž¸àŸ¸䜷
ã

üû+‰
B

Ö·
Ü·
œ·


à

à

ã

Ö·

Ü·


ËD4�
±™üÍ[
Îå

—æ


å
æ



¹
Ü·



¹

Ö·
&F˜"$£Ÿ¸Ö&E

Ö·
4€

¹“"
Ü·

Ž½Ä�Ž¸Òœ·
ç
è
é
&F&G&Hè
é
"$_aL¯$´
ä

ä
™½üÊVLÍ


º
»
¼„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ºœ·



»Ì�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

¼
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

™½

ä

å
ä

è

Ö·

Ü·

$Û

âÙñüƒ
-L†


½
½œ·
ýÞ

ä

�

ä

é

Ö·

Ü·

$‘
tä

”'tõ

Tù


Bþƒ	
ˆ 4&E
ë
ì
§× `
ë

í

ùõ
2
„¾
ë

î

æö,H
¥‚

ë

ð
k<O
�

ë

ñ
·
$Xϯ
ë

ò

¥÷\u

ë

ó
l–L„t'tT;ceRTACìc2ü÷E
Îõ

—ö


õ
ö

Ž¸üŸ¸€°¸T±Ó¸
÷
Àc
÷
#%(*üÃ8Æ
¾
¿
À
¾Ó¸


¿ c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


À
ò¹

ô

Ê
ô

÷

Ö·

Ü·

$Ë
±Ñäì
Îù

—ú


ú

ù
Ž¸ñŸ¸õÓ¸
û

ü�+�
B

Ö·
Ü·
Ó¸


ø

ø

û

Ö·

Ü·


ËD4¡
±­üáe
Îý

—þ


¥ÿ

ý
þ

ÿ

Ü·


™½˜"Û¼ݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

¥L¼Ÿ¸êÍì


‰Éíµ½4š“"
Ü·

»Èä©Ž¸æÓ¸
€�‚&F&G&H�‚"$df`bLÍ$Ò
ü

ü
‰ÉüáOLä


Á
Â
ľ
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ÁÓ¸



ÂÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

Ã
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ÄÈ

ü

ü
ü

�
Ö·

Ü·

‰É
$ò

âÙˆü 
-L£



Ä
ÄÓ¸
ýÞ

ü

­

ü

‚
Ö·

Ü·

‰É
$®
¬�
?-D¥
$©

B«	¸	
ˆ 4&E
„…§
¨ñ4&‚Ø
„
†
�öl@
Ӓ

„
‡
�ö
•í

„
‡
ùõ
^
„¾
„
ˆ
æö,t
¥‚

„
Šk<{
�

„
‹·
$„
ϯ
„
Œ
¥÷\¡


„
�lǤ´Ü2£tS{TgjlY[HJì�
9üØ#
�
“�

—‘
�
‘�Ž¸ÝÍì


‡º
á±ùä±¹
’
$& "%'ü‚4�
B


Ö·
‡º
¹ª
±¹


Ž
Ž
’
Ö·

‡º

¹ª


ËD4”
initÁ$ 
±©ü¼d
Δ
“•

—–
”•
–
¹ª

‡º
™½˜"‡º
žÍÐűùȵ½4ù“"
¹ª

ÅÒ¼ˆŽ¸Á±¹
—˜ƒØ„Ø
˜UWZ\\§4¬
“
“‡º
ü½I$À



Å
Æ
Ç„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ű¹



ÆÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

Ç
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã



±¹
į

“
Ï
“
˜
Ö·

‡º

¹ª

$Å

âÙÛ„³
ˆ1DÆ
$Ê

Bí	ó	
ˆ 4&E
š›§
¥÷\*

š
œ
ùõ
E
„¾
š
�
æö,Z
¥‚

š
Ÿk<a
�

š
 ·
$jϯ
š
¡l‚ìol;_LNNP=?,.ü¡$
¥£

£¾Ï¦Ó‰4¾¢»
¤
üÌ'Ú

é¤
¢»


¢

¢
¤

é¤


ËD4Þüº/
¥¦

¦¾Ï¿Ó‰4⢻
§¨©&F&G&H©¨*,Lð$õ
¥

¥¡²
üŠUL�

È
É
Ê„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


È¢»



ÉÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

Ê
Ÿö


¥

¥
¥
¨

é¤

$›

âÙ±üÑ-LÔ

Ë
Ë¢»
ýÞ

¥

Þ
¥
©

é¤

$ßTØ
£4<å
é

B‘
–

ˆ 4&E
«¬§× `
«
­
ùõ
2
„¾
«
®k<H
�

«
°·
$Qϯ
«
±
¥÷\n

«
²lLmt']T;NP=?ì\.üÔ?
δ
—µ

´µ
Ž¸ÙŸ¸Ý°¸TˆŠ½
¶Àc
¶#%(*üš8�
Ì
Í
Î
ÌŠ½


Í c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


Î
ò¹

³
¡
³
¶
Ö·

Ü·

$¢
±¨´£
θ
—¹

¸¹
Ž¸¨Ÿ¸¬Š½
º
üÀ+Î
B

Ö·
Ü·
Š½


·
·
º
Ö·

Ü·


ËD4Ò
±Þü‘W
μ
—½

¥¾
¼¾½

Ü·

»È˜"‰É柸š›É�µ½4Ĵɤӎ¸–Š½
¿ÀÃ&F&G&HÃÀ"$OQTVLï$ô
»
»‰ÉüƒOL†


Ï
Ð
Ñ„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ÏŠ½



ÐÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

Ñ
žÌ

»
ž
»
À
Ö·

Ü·

‰É
$”

âÙª,Â
À<closure_kind>ÁÁ
<closure_signature>ÁÁ
<upvars>ÁÁ

Á
ÀÁ
Ö·

Ü·

‰É


êÀÄÈ


„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•

Š½


Ð
À
ÃåÂ

ÜåÂ

úåÂ

Â
ÀÂ
Ö·

Ü·

‰É

»È‰É

¼çü€-Lƒ


Ò
ÒŠ½
ýÞ

»
�
»
Ã
Ö·

Ü·

‰É
$ŽDö
Ö:l�
L…

B¾
Ã

ˆ 4&E
ÅƧנ`
Å
Ç
ùõ
2
„¾
Å
Èk<H
�

Å
Ê·
$Qϯ
Å
Ë
¥÷\n

Å
ÌlLmt']T;NP=?ì\.üåD
ÎÎ
—Ï

Ï
ÎŽ¸êŸ¸î°¸Tž½¾
ÐÀc
Ð#%(*ü°8³
Ó
Ô
Õ
Ó½¾


Ô c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


Õ
ò¹

Í
·
Í
Ð
Ö·

Ü·

$¸
±¾ÜØ
ÎÒ
—Ó

ÒÓ
Ž¸ÝŸ¸á½¾
Ô
üú+ˆ
B

Ö·
Ü·
½¾


Ñ
Ñ
Ô
Ö·

Ü·


ËD4Œ
±˜üÐd
ÎÖ
—×

¥Ø
×
ØÖ³ÈLªŸ¸Ù›Éܵ½4ˆ´Éä—Ž¸Õ½¾
ÙÚÜ&F&G&HÜÚ"$OQTVL»$À
Õ
Õ‰ÉüÏKLÒ


Ö
×
Ø„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


Ö½¾



×Ì�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

Ø
žÌ

Õ
æ
Õ
Ú
Ö·

Ü·

‰É
$Ü

âÙò,ø
Ú
ÃåÛ

ÜåÛ

úåÛ

Û
ÚÛ
Ö·

Ü·

‰É

­ç

Ü·

üš-L�


Ù
Ù½¾
ýÞ

Õ
§
Õ
Ü
Ö·

Ü·

‰É
$¨œ˜
"@L®
,²

Bðë
ñ

¯]$
í	
Þߪ
ˆ 4(&E
Þà§
ùõ
@
„¾
Þ
ák<V
�

Þ
ã·
$_ϯ
Þ
ä
¥÷\|

Þ
弄l!pt5]TINP=?ìj.´¤¥ç
¦è

çè
¾Ï©èˆ¬ü¿
é
üÁ\Ï
B

é¤
ï
ü¿


æ
æÓ‰4ƒâ‰4–
é
é¤

ï

¬Ó
­ÙüœU¥ë
¦ì

ëì
¶Štáèˆ¤Ó‰4Ë≴ھÏ¡ü¿
íîï&F&G&Hïî"$GILø$ý
ê
ꡲ
ü’QL•


Ú
Û
Ü„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


Úü¿



ÛÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

Ü
Ÿö


ê
©
ê
î
é¤

ï

$Ÿ

âÙµüî-Lñ

Ý
Ýü¿
ýÞ

ê
û
ê
ï
é¤

ï

$üüï	­
Lò	
Þ


Þ
ß
à
ᄾ
„¾
ùõ


†¾‰
˜X
$]È=„kt•


Þé¤

„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•



ßï


àÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

á
Ÿö

¥ñ
¦ò

ò
ñ
’
¾Ïü	èˆÿ	Ó‰4ö
≴…¶ŠtŒ
ð
é¤

ï

firstÁ,‡

secondÁ4Ÿ


âÙ¸
UWZ\dÁ
•EDÐ
$Ô

Bϴ
ˆ 4&E
ôõ§
¨ñ4&‚Ø
ô
ö
�öl@
Ӓ

ô
÷
�ö
•í

ô
÷
ùõ
^
„¾
ô
øk<t
�

ô
ú·
$}ϯ
ô
û
¥÷\š


ô
ül¯¤œÜ2‹tScTgTVCEìˆ
5üá!
Åþ
Îÿ

þÿ

 ùêÛÀ
€
æü‰-—
B

ŠúÛÀ


ý
ý
€
Å
³ª


ËD4›ü�98â
΂

â‚
 ù•¦û4¢µû,«‰Â
ƒ„ƒØ„Ø
„,.\Ð4Õ
�
�ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

‹ûüõI$ø


ã
ä
儾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ã‰Â



äÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

å
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã



‰Â
į

�
‡
�
„8
³ª

$ý

âÙ“TÞ
DIDë
$ï

BÍÑ
ˆ 4&E
†‡§× `
†
ˆ
ùõ
2
„¾
†
‰
æö,H
¥‚

†
‹k<O
�

†
Œ·
$Xϯ
†
�
¥÷\u

†
Žl–L„t'tT;ceRTACìc2üç:

�

�Ž¸ì°¸T–¤Ã
‘Àc
‘ü¨8«
æ
ç
è
æ¤Ã


ç c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


è
ò¹

�

¯
�
‘

Ö·

$°
±¶ŒÌ

Γ

“
Ž¸Ñ¤Ã
”

üä7ò
B
Ö·
¤Ã


’

’
”

Ö·


ËD4ö

£kL‚üÊ2

Ζ

–Ž¸Ïµ½4õ¤Ã
—˜™&F&G&H˜™*,Lƒ$ˆ
•

•™½üžXL¡

é
ê
넾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


é¤Ã



êÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

ë
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ



¤Ã
&F

•

¹
•
˜

Ö·

$¯

âÙÅüŠ
-L�


ì
ì¤Ã
ýÞ

•

—

•
™

Ö·

$˜
É
™

Ãåš


Üåš

úåš

š
™š
Ö·






¤Ã
Tý
{NtŠ
TŽ

Bò÷
ˆ 4&E
œ�§× `
œ
ž
ùõ
2
„¾
œ
Ÿ
æö,H
¥‚

œ
¡k<O
�

œ
¢·
$Xϯ
œ
£
¥÷\u

œ
¤l–L„t'tT;ceRTACìc2üÿE
Φ
—§

¦§
Ž¸„Ÿ¸ˆ°¸T¹ÓÄ
¨Àc
¨#%(*üË8Î
í
î
ï
íÓÄ


î c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


ï
ò¹

¥
Ò
¥
¨
Ö·

Ü·

$Ó
±Ùäô
Ϊ
—«

ª«
Ž¸ùŸ¸ýÓÄ
¬
ü—3¥
B

Ö·
Ü·
ÓÄ


©
©
¬
Ö·

Ü·


ËD4©

ØmLµü«^
ή
—¯

®¯


ð
Ü·



𙽘"$„Ÿ¸´µ½4á

ð“"
Ü·

¬—ÄðŽ¸°ÓÄ
°±²&F&G&H±²"$XZL�$•
­
­™½ü«TL®


ñ
ò
ó„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ñÓÄ



òÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

ó
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ



ÓÄ
&F

­
Â
­
±
Ö·

Ü·

$¸

âÙÎüÈ-LË

ô
ôÓÄ
ýÞ

­
Õ
­
²
Ö·

Ü·

$Ö¬¢
TDº
$¾

BŸ£
ˆ 4&E
´µ§‹‹
´
¶×- `
´
·
ùõ
A
„¾
´
¸k<W
�

´
º·
$`ϯ
´
»
¥÷\}

´
¼l“L�L'rt6bTJSUBDìk3üï:

ξ

¾Ž¸ô°¸Tž‚Æ
¿Àc
¿ü°8³
õ
ö
÷
õ‚Æ


ö c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


÷
ò¹

½

·
½
¿

Ö·

$¸
±¾ŒÔ

ÎÁ

Á
Ž¸Ù‚Æ
Â

üì7ú
B
Ö·
‚Æ


À

À
Â

Ö·


ËD4þ

£kLŠüÒ2

ÎÄ

ÄŽ¸×µ½4ý‚Æ
ÅÆÈ&F&G&HÈÆ*,L‹$�
Ã

Ù½ü¦XL©

ø
ù
ú„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ø‚Æ



ùÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

ú
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ



‚Æ
&F

Ã

Á
Ã
Æ

Ö·

$·

âÙÍ<ò
Æ

ÃåÇ


ÜåÇ

úåÇ

Ç
ÆÇ
Ö·


°çêÀ


„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•

‚Æ


ü‚-L…

û
û‚Æ
ýÞ

Ã

�
Ã
È

Ö·

$�TÌ
qYtÙ
TÝ

BÄÊ
ˆ 4&E
Ê˧נ`
Ê
Ì
ùõ
2
„¾
Ê
Ík<H
�

Ê
Ï·
$Qϯ
Ê
Ð
¥÷\n

Ê
ÑlLmt']T;NP=?ì\.ü„E
ÎÓ
—Ô

ÓÔ
Ž¸‰Ÿ¸�°¸T¾½Ç
ÕÀc
Õ#%(*üÐ8Ó
ü
ý
þ
ü½Ç


ý c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


þ
ò¹

Ò
×
Ò
Õ
Ö·

Ü·

$Ø
±Þä 
Î×
—Ø

Ø
׎¸¥Ÿ¸©½Ç
Ù
üÃ3Ñ
B

Ö·
Ü·
½Ç


Ö
Ö
Ù
Ö·

Ü·


ËD4Õ

ØmLáüß^
ÎÛ
—Ü

Ü
Û

ÿ
Ü·



ÿ™½˜"$¸Ÿ¸èµ½4•

ÿ“"
Ü·

«­ĤŽ¸ä½Ç
ÝÞá&F&G&HáÞ"$XZLÄ$É
Ú
Ú™½üßXLâ


€
�
‚„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


€½Ç



��

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

‚
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ



½Ç
&F

Ú
ú
Ú
Þ
Ö·

Ü·

$ð

âÙ†<£	
Þ
Ãåß

Üåß

úåß

ß
Þß
Ö·

Ü·


´¦

„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•

½Ç


4Ø	
Þ
Ãåà

Üåà

úåà

à
Þà
Ö·

Ü·


»ÈêÀ

ܲü‰
-LŒ


ƒ
ƒ½Ç
ýÞ

Ú
–

Ú
á
Ö·

Ü·

$—
–
í_D‰
$�

Bõü
ˆ 4&E
ãä§× `
ã
å
¨ñ45‚Ø
ã
æ
ùõ
L
„¾
ã
çk<b
�

ã
é·
$kϯ
ã
ê
¥÷\ˆ


ã
ël–L„¤'ttAcTUTVCEìv4ü¢J
Îí

Ÿ.î

—ï
î
ï편§Íì


ØÉ
«±ù°°¸TáŽÉ
ðÀc
ð460257üó8ö
„
…
†
„ŽÉ


… c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


†
ò¹

ì
ú
ì
ð
Ö·

ØÉ

¹ª

$û
±�ü—!
Îò

Ÿ.ó

—ô
ó
òôŽ¸œý¶ ±ù¥ŽÉ
õ
 "%'ü¿+Í
B

Ö·
¹ª
ŽÉ


ñ
ñ
õ
Ö·

ØÉ

¹ª


ËD4Ñ
±ÝüÌr
Î÷
—ø


Ÿ.ù
÷ø
ù
Ü·

»È˜"òÈ
ºŸ¸ÕÍì


òÈ
ص½4‡‚Ø

òÈ
4˜´É´§Ž¸ÑóÉ
úûü&F&G&Hüû"$ikegLÅ$Ê
ö
ö

òÈ
ƒØüãULæ



‡
ˆ
‰„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


‡óÉ



ˆÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

‰
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

ç¼

ö
ú
ö
û
Ö·

Ü·

òÈ

$ð

âÙ†ü¢-L¥

Š
ŠóÉ
ýÞ

ö
¯
ö
ü
Ö·

Ü·

òÈ

$°<Ÿ
ü
Ãåý

Üåý

úåý

ý
üý
Ö·

Ü·

òÈ


¬‘�ß


ü†T›
rfd¨
D¬

B®
·

‹h$
œ
ÿ€…
ˆ 4(&E
ÿ�§
¨ñ4C‚Ø
ÿ
‚
�öl]
Ӓ

ÿ
ƒ
�ö
•í

ÿ
ƒ
ùõ
{
„¾
ÿ
„k<‘

�

ÿ
†·
$š
ϯ
ÿ
‡
¥÷\·


ÿ
ˆ¼Êl!¶¤5£ÜO’tpjT„
\^JLì¥
;ü‘$
ÅŠ
΋

‹
Š
 ùšÌÊ
Œ
–ü¼-Ê
B

ŠúÌÊ


‰
‰
Œ
Å
³ª


ËD4ÎüÕW8‹¥Ž

–�

�
��Ž
‹

¹Ì
&FÖ¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â

é®

Õµ
œô©«ÝÎì


¹Ì
à&E

¹Ì
ÜíÁ•Ú“í


¹Ì
,‹úË
‘’ƒØ„Ø
’-/bd^`\³4¸
�
�Ö¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

é®

Õµ
üÜI$ß




Œ
�
Ž„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ŒúË



��

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

Ž
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã



úË
į

�
î
�
’8
é®

Õµ

¹Ì

$ä

âÙúŒº
bkdÎ
DÒ

Bß
ã

ùõ

„¾
”
•k<#
�

”
—·
$,ϯ
”
˜
ˆ 4F&E
”
™
¥÷\d

”
š
¯]$‰

í	
”›ª
©1Lš
¨
”œÙl™LŠŒy{¤8jìR[¼vL„“
9Üú
¥ž

ž¾ÏÿÓ‰4‚—Í
Ÿ 

üœ$ª

é¤
—Í


�

�
Ÿ

é¤


ËD4®üÃLü–(% Peek at the next item in the stream.Á$Ð


�
�—Í


é¤

�¡

�

Õ
�
“í


é¤
,‰
 

é¤

Þ{€Éã


 

8É

É

 ¢
é¤


¥è


ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ


8¡²



8—Í

Íì



é¤

8¡©‚Ø

§Ñ¸

§ÑƒØÄÐÊŸÑкÑÖÉÑÜ
 †s
 
<coroutine_kind>Á¢

<resume_ty>Á¢

<yield_ty>Á¢
<return_ty>Á¢

úå¢

¢
 ˜è
üÃ&
¥¤

¤¾ÏÈÓ‰4Ë—Í
¥¦&F&G
¦ "Lð$õ
£

£¡²
üŠ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

¢•4«
¨

š•*ûãš•6ûã*©ª­°³¶¸º½¾¿ÁÂÄÆÈÊÍÏÐÑÒÓ©ª­°³¶¸º½¾¿ÁÂÄÆÈÊÍÏÐÑÒÓ°Æѳ¾¶ÁÄÏÒ©¿ÊÂͺнÈÓª¸­üÆC
ü¸F
C Consumes and returns the next value in the stream or `None` if theÁ¼ƒ
 stream is finished.ÁŸ
ú”§
 Equivalent to:Á¾
úlÆ

 ```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.Áõ
útý
 # 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);Á<®

¤ª<º

´ª$É



“
“¢•
œ
œ
‹h
Ÿ
ËD
ô
 
áD
ô
èΟ6ú`
“
¢•

¨


Î

¨
“í


¢•,ƒ

©

¢•
$Ó
üó'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.ÁÅ
ú”Í

Œæä
úlì

³æüþ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ö'





”
”¢•
®

®

ˆy
±

à@
ÿ
²

áD
ÿ
HQˆ{žá
”
¢•

¨
¥«

–¬
«
¬

…(

¨Á•ÿ'
©«‚(
ûãܽ(


¢•&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



¢•¹ª
‘

‘

Ã_
”

ËD
«
•
±
«
Ö¯K‰´Êu
¢•
¹ª


¨
¥®

—¯
®
¯

¨Á•Ò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§<



¢•¹ª
¾

¾

¡b
Á

ËD
Å
Â
±
Å
¢«/à;ªz
¢•
¹ª


¨
¥±

—²
±
²

¨Á•±<
±ù´<
€…ôí<

¹ª

‹…˜"·È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


¢•Ü·
õ
õ
Ãu
ù
ËD
ã
ú
ïu
ã
û±
ã
L²Îß'Úí
¢•
òÈ

Ü·


¨
—´


Ÿ.µ
µ´


¨Ÿ¸«H
Ò»®H
“"
Ü·

‹…ÄêH

Ü·

‹…˜"òÈ
ÿH
ë»4‘I
³…,§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


¢•ï
ë

ë

„e
î
¬
Þ
ï
­
Þ
ð

±e
Þ
Õõb˜PI‹¦
¢•
ï


¨

¦·


·


¨èˆ½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


¢•Ü·
Ñ
Ñ
ÝS
Ô
ËD
Ó

Õ±
Ó


ȸÊ"àM!
¢•
Ü·


¨

—¹


¹


¨Ÿ¸€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



¢•¹ª
þ
þ
¾V
�	
ËD
ë

‚	±
ë

SŽ2€~ž_
¢•
¹ª


¨
¥»

—¼
¼»


¨Á•…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ÿ€


·Œ,��


–ª—�

úDŸ�


�£”¬�


ž£DÃ�


¹£üÐ�
/

�¨¬„‚


Ø£üž‚
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.Áüó†
.

¬Öü¦‡
.

¬ÖüÙ‡
.

¬Ö,Œˆ


–ª<–ˆ


´ª$¥ˆ


¢•í	
í	
¯]

ï	
ËD
š
Ÿéû+Ó² ¶

¢•

¨


¨
³…,Öˆ


½

¢•
$ªˆ

üªŽ
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);Á<’Ž


¤ª<žŽ


´ª$­Ž


¢•Ÿ
Ÿ
œp
¡
ËD
´
¢
£k
´
70´%b»

¢•

¨


¨
³…,èŽ


¾

¢•
$²Ž


¹¸Ž

üÏ•
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Ò•



¢•Ü·
Ä
Ä
»r
Ç
ËD
Ê
È
Øm
Ê
É
ìr
Ê
ÆtãL¾jÖC
¢•
Ü·


¨

—À


À


¨Ÿ¸Ý•



–“"
Ü·



–�…Ô—–



–
Ü·

ëè˜"$­–

³…,Á–


¿
¢•
Ü·

$à•


±æ•

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);Áüïš
*

×ß<ž›


¤ª<ª›


´ª$¹›


¢•Í
Í
‡k
Ï
ËD
†
Ð
£k
†
xæ_6ÂÈå

¢•

¨


¨
³…,ô›


Á

¢•
$¾›


¹Ä›

ü±£
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´£



¢•Ü·
ò
ò
¯m
õ
ËD
œ
ö
Øm
œ
/[S®oŠˆ
¢•
Ü·


¨

—Ã


Ã


¨Ÿ¸¿£



—“"
Ü·



—�…Ôù£



—
Ü·

Àõ˜"$�¤

³…,£¤


Â
¢•
Ü·

$£


±È£

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));Á<�±


¤ª<™±


´ª¨±





˜
˜¢•
Ü·
æ
æ
¢D
ê
ËD
E
ë±
E
ì
áD
E
½/سíïã
˜
¢•
Ü·


¨

—Å


Å


¯±


¨Ÿ¸¬±

Êñ,ò±

™šÌ„²


Ü·

‹…˜"$™²


Ä
¢•
Ü·

$´±


±º±

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));Á<ľ


¤ª<о


´ªß¾





™
™¢•
Ü·
¤
¤
€I
¨
ËD
Z
©±
Z
ª
áD
Z
)p1*ÙŽ¡}
™
¢•
Ü·


¨

—Ç


Ç


æ¾


¨Ÿ¸ã¾

Êñ,©¿

™šÌ»¿

¸„$п


Æ
¢•
Ü·

$ë¾


±ñ¾

>@üØÇ
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);ÁÝÄ

úüåÄ
-

Ùíü—Å
-

�îüÉÅ
-

ÇîüûÅ
-

¨�ü­Æ
-

ß�üßÆ
-

–‚ü‘Ç
*

þî<ÀÇ


¤ª<ÌÇ


´ª,ÛÇ



¢•ï
â
â
æL
å¬
o
æ­
o
	—‰`Õµ
¢•
ï


¨

¦É


É


¨èˆáÇ

â‰Ì›È

еŒ¢È

³…,ÄÈ


È
¢•
ï

$äÇ


¹
,êÇ

>@üÎÍ
�

üüÈ
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);Á<¶Í


¤ª<ÂÍ


´ª$ÑÍ




¢•‡º
¹ª
«	
«	
¢Y
¯	
ËD
„
°	
ÔY
„
±	±
„
²	
áD
„
¿>
•S‹
¢•
‡º

¹ª


¨
“Ë

—Ì
ÌË


¨ÍÐÖÍ

±ùÙÍ

³…,£Î

“"
¹ª

‡º
�…̵Î


¹ª

àŸ˜"‡º
ÍÎ


Ê
¢•
‡º

¹ª

$ÜÍ



îÐ$âÍ


±ëÍ

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);Á<Íà


¤ª<Ùà


´ª<èà



¢•�
�
ÅO
“
ËD
„

”
ôO
„

•
†P
„

–
áD
„

wNrx 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µ–²ªÝ
Ý
©“

ß
ËD
„
à
»Š

„
á
ËŠ

„
â
Ú“

„
’¤#bO¼‹

¢•

¨


¨
³…,”ÿ


Ï

¢•
$Ñþ



ËŠ
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");Á<Þ�

¤ª<ê�

´ª
»

¬Ä„ü�
Äö�
ŒÊž

¢•Ù§
µ
µ
é�

·
ËD
£
¸
ÂA
£
¡WÙ½pZÚ

¢•

¨


¨
³…,¨Ÿ

Ð

¢•
$Üž


ÂADâž
üÔ¥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
¼
÷æ|7ðÚ‰—

¢•

¨


¨
³…,¤¦

Ñ

¢•
$à¥


ËŠ
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Ӧ
€
¢•½ÏÑ
Ñ
–Š

Ó
ËD
Ø
Ô
»Š

Ø
Õ
ËŠ

Ø
Ö
ÛŠ

Ø
×
èŠ

Ø
0ôœ(¥YC

¢•

¨


¨
³…,ý¶

Ò

¢•
$£¶

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à½

¢•ß

ß

‡|
á

ó0
”
â

ËD
”
×fE* }Ÿ

¢•

¨


¨
³…,™¾

Ó

¢•
$é½
ü˾2


ÎÕ

ÕÎì


Ö·
о
µ½4÷¾
Ö·
ü­¿˜

„°¿

BýÞýÞýÞ

ÖTÏœÜ-�?�?�„¿üýA> Adapters for [`Stream`]s created by methods in [`StreamExt`].ÁDÇ
æL,û
â܃

ÝS4‚
ÑÝê

¾VLŠ
þÞƒ
¯]$•
í	ߪ
Ã_›
‘
àÄ
¡bD 
¾
áÝ
„e,ª
ë
âó
‡|D±
ß
ã§
‡k$»
Íä›
¯mLÁ
òå³
œp$Ì
ŸæÉ
»rLÚ
Äçâ
Ãu$å
õèþ
–Š
l¦
Ñüð
©“
<µ
Ýý·
é�
„¾
µþ¸ŒÞd
g
T
W
D
G
4
7
$
'




ôöâäÐÒ¾À¬®šœ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ÁT© ready.Á´út¸
´ìÇú„Ë
úûÜú<à
´ªüè2
ȧ›úüŸ/
�¨¼Ï
Ȩüç*' let mut none = stream::empty::<i32>();Á’úü–(% assert_eq!(None, none.next().await);Á<¿
¤ª<Ç
´ª,Ü
šÖ


¥÷

÷
¾Ïâ
ö

é¤
�
¥ù

ù
¾Ï”šÖ
úûü&F&G&Hüû"$L±$¶
ø

øé¤
üÅJLÈ

š
›
œ„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ššÖ



›Ì�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

œ
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

é¤


ø

Ü
ø
û

é¤

$Ò
èü·-Lº

�
�šÖ
ýÞ

ø

Ä
ø
ü

é¤

$Å,¤Q�Q�d�d�D¼$À
ˆˆ
ˆ 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));Áüå*
þî<�
¤ª<˜
´ª$§
Á×
ˆ
ˆ
ù„

Šù
€
‹
•…

€
‹‘v´§ @n



Á×
ÉL

š‰

‰¶”¬ÇL

Á×
d×
ˆ

Á×

´¯%'ü®1
š‹

‹¶”³ùM

Á×
DÖ…×
Œ�Ž&F&G&H�Ž24Læ$ë
Š

Š

Á×
úMü€ULƒ

ž
Ÿ
 „¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ž…×



ŸÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

 
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

µ›

Š

›
Š
�

Á×

$‘

âÙ§üí
-Lð


¡
¡…×
ýÞ

Š

ú

Š
Ž

Á×

$û
$Îv�v�‰�‰�Dã$ç
��
ù„
$
ˆ
’”‘
ˆ 4&E
’•§³
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.Á½útÁ
´ìÐú<Ô
´ªüÜ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);Á<Ÿ
¤ª<§
´ª$¶
é¤
ä×


¥ž

ž
¾Ï»
�

é¤

»,¾Ô‘
¥ 

 
¾Ï–ä×
¡¢£&F&G&H£¢"$L²$·
Ÿ

Ÿé¤
üÆOLÉ

¢
£
¤„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


¢ä×



£Ì�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

¤
ù�

Ÿ

á
Ÿ
¢

é¤

$×

âÙíüÒ-LÕ

¥
¥ä×
ýÞ

Ÿ

ß
Ÿ
£

é¤

$à$õ›�›�®�®�\Š<Ž
´•–
ˆ 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‘
´ì ú„¤
úûµúl¹
 ```no_run矂2
ȧúú”þ
ž£¬‘
Ø£ü§1.     let mut never = stream::pending::<i32>();ÁÙúüÝ#      // This will never completeÁÜ�     never.next().await;Á�ú¼¡     unreachable!();Á,¹
–ª<¿
´ª<Ô
ãØ


¥µ

µ
¾ÏÜ
´

é¤
ì�
¥·

·
¾Ï’ãØ
¸¹º&F&G&H¹º"$L±$¶
¶

¶é¤
üÅJLÈ

¦
§
¨„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


¦ãØ



§Ì�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

¨
ù�

¶

Ü
¶
¹

é¤

$Ò
èü³	-L¶	

©
©ãØ
ýÞ

¶

À	
¶
º

é¤

$Á	<ŸÀ�À�Ò�Ò�t½TÁ
ƒœ
ˆ 4&E
¾¿§Y4% 
¾
Àpoll_fnÁ<>Ç€

¾
ÁŽ
$Vše
¾
ÂŽ
 e
¾
Â
ùõ
j
„¾
¾
Ã
æö,
¥‚

¾
Åk<†

�

¾
Æ·
$�
ϯ
¾
ÇlÆœµ¤1Ÿ|K�l`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
´ªl–GÍÙ


È
È
Ð
ýÙ

ƒÚ


§;D¤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Ì
Ì
Ñâ­
â­
Ã_
å­ù

æ­±
Å@
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Í
Í
Ôâ­
â­
Ã_
å­ù

æ­±
Å@
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Î
Î
×â­
â­
Ã_


¤œ

œ
Íì


¼Î
Ô
ÒÛ
�ž

ìœüò
%" Create a new `StreamNotifyClose`.Á£
¼Î
ÒÛ


›

›
�

¼Î


ËD4§üè$ü�  Get back the inner `Stream`.Á¦úü®52 Returns `None` if the stream has reached its end.ÁTï
ÒÛ
ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

¼Î


›

›
ž

¼Î

$úü«
<
¤ 

 Õª°
&E

¼Î
4à
ÒÛ
¡¢¤&F&G&H¤¢13Lî
$ó

Ÿ

ŸÛ¼ݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ



¼Î
&Fü�XL“

È
É
Ê„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ÈÒÛ



ÉÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

Ê
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ



ÒÛ
&F

Ÿ

«
Ÿ
¢

¼Î

$¡

âÙ·DÈ
¢

Ãå£


Üå£

úå£

£
¢£
¼Î



„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•

¼Î

œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ê®


§ô
üÌ-LÏ


Ë
ËÒÛ
ýÞ

Ÿ

Ù
Ÿ
¤

¼Î

$Úá
¤

Ãå¥


Üå¥

úå¥

¥
¤¥
¼Î


ëÁ
ü‡ø�¤Ã�ä­ühPM A wrapper around [`tokio::sync::mpsc::Receiver`] that implements [`Stream`].Á¹
úl½

ÀäË
ú<Ï

´ªÔ×

ñ¡üò
/, 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ÁlÆ
 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¸

¥©

©
¾ÏǼ¤
ÙÞNµ�ÊóB


ª ”Ð,Ð

¨

¨„¥
(¥7
¥¬

¬¾Ïl¿c

é¤
Ǽ¤
­Àc
­Ž�UW


Ì
Í
Î
̼¤


Í c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


Î
ò¹

«

¥
«
­

é¤

þ
±
üà%	üqY	V A wrapper around [`tokio::sync::mpsc::UnboundedReceiver`] that implements [`Stream`].ÁË
	úlÏ
	
ÀäÝ
	ú<á
	
´ªÔé
	
ñ¡ü„8	5 use tokio_stream::wrappers::UnboundedReceiverStream;Áü½ 	
·åÞ	úüâ/	
�¨ü’N	
 ·üá-	* let (tx, rx) = mpsc::unbounded_channel();ÁŒ�	 tx.send(10)?;ÁŒ¡	 tx.send(20)?;Áü³*	
æ¸lÞ	
™¹ì	úüð6	3 let mut stream = UnboundedReceiverStream::new(rx);Áü§.	
ó¹üÖ.	
«ºü…*	
þîd°	
ðº<½	
¤ª<Å	
´ªÍ	úüÑY	V [`tokio::sync::mpsc::UnboundedReceiver`]: struct@tokio::sync::mpsc::UnboundedReceiverÁü«#	
ý»¼ë	

¥¯

¯
¾Ïƒ	ç¥

¬p<XZ—©


° ÜŒ	,Œ	
'
®

®­¦
(Ø	8
¥²

²¾Ïl±¾ƒ	ç¥
³Àc
³†ˆMO


Ï
Ð
Ñ
썴


Рc
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


Ñ
ò¹

±

Ø	
±
³

é¤

ö
±üdø

»

¬Ä€›À•Dü


É
ˆ 4 &E
´µ§
ùõ
! 
„¾
´
¶k<6 
�

´
¸·
$? ϯ
´
¹InstantÁ<X 
­e
´
»
ã¦
Da 
Ñe
´
¼l †l sL* dfSU\J >@-/œ£ –§
¾¿

üä& ü½"  Create a new `IntervalStream`.Áë Ù§
–§


½
½
¾

ÂADï üà# ü¹"  Get back the inner `Interval`.ÁTç –§
Ù§


½
½
¿
$ò ô¢	 –§
ÁÂÃ&F&G&HÃÂLÇ	 $Ì	 
À
À­e
­e
²È

®eÀ
Üc
SOf"¥X—üá	U Lä	 
Ò
Ó
Ô„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


Ò–§



ÓÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

Ô
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

¹Ì

À
ü	 
À
Â
$ò	 

âÙˆ
 üï
- Lò
 

Õ
Õ–§
ýÞ

À
ü
 
À
Ã
$ý
 üÃ' –§
Åâ
Åìñ 4ô 

Ö
Ö–§

ÖÙ§


Ä
û 
Ä
Å
$ü ü®' –§
Çå
ÇüÜ% 4ß 

×
×–§


×Ù§



Æ
æ 
Æ
Ç
$ë Ä’
D¦Ìï üm= : A wrapper around [`Interval`] that implements [`Stream`].Á«
 úl¯
 
Àä½
 ú<Á
 
´ªüÉ
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));ÁL· 
·Œ,Á 
–ª<Ç 
¤ª<Ï 
´ª× úüÛ. + [`Interval`]: struct@tokio::time::IntervalÁüŠ# 
ý»9tú –§
žËŽ–X
Ê|� ,� 
´
É
ÉÙ§
(· :–§
ÌÀc
Ì"$

Ø
Ù
Ú
Ø–§


Ù c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


Ú
ò¹

Ë
· 
Ë
Ì
Æ
±ÌdÊ	
»

Ä»pM°G
ƒ$¾	
4½	
Ϋ	

DÎ	


â
ˆ 4!&E
ÍΧioÁ!
¦
Í
Ï
ùõ
.!
„¾
Í
Ðk<C!
�

Í
Ò·
$L!ϯ
Í
ÓDirEntryÁDc!
Ý

Í
Õ
©¨
<m!
Ì

Í
Öl!�<!‰l$!yL7!jlY[LW!CE24”Ò!
ب
ØÙ

ü‘%!üë!! Create a new `ReadDirStream`.Á˜!›©
ب


×
×
Ø

ôBDœ!ü‹"!üå!! Get back the inner `ReadDir`.ÁT’!ب
›©


×
×
Ù
$�!ìÌ!
ب
ÛÜ&F&G
ÜLð!$õ!
Ú
ÚÖ¿Ù¿
Ú¿«


Û¿ˆ
Ü¿
Ý¿


Þ¿ˆ

‚†f|Â

Ý

Ý

—Û
Þ
	file_typeÁ
ç
ß
À
ç
'~Âîgn‘ò
ÄÐ
ü—	X!Lš	!
Û
Ü
Ý„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


Ûب



ÜÌ�

�
k
�

¾ó

¸�

�

Ñó

¸�

�

êó

¸�

�

ûó

¸�

Ò�

�ô

¸�

f'EwÚ]¾å

Ý
œØžØ
ŸØÈ


 Øˆ
¡Ø

¢Ø´



‰‰Nµý¤Ã

ۼݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ



ب
&F

Ú
²	!
Ú
Ü
$¨	!

âÙ¾	!ü¹
%!
ب
Þâ
Þäå
!4è
!

Þ
Þب

Þ›©


Ý
ï
!
Ý
Þ
$ð
!ü¡%!
ب
àå
àüÍ$!4Ð!

ß
ßب


ß›©



ß
×!
ß
à
$Ü!¼ú	
V¦Ä !üxG!D A wrapper around [`tokio::fs::ReadDir`] that implements [`Stream`].ÁÀ
!úlÄ
!
ÀäÒ
!ú<Ö
!
´ªäÞ
! 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());Á,à!
–ªdæ!
ðº<ó!
¤ª<û!
´ªƒ!úü‡5!2 [`tokio::fs::ReadDir`]: struct@tokio::fs::ReadDirÁü½#!
ý»;l«!ب
‹l¸1}¹#=
ãt¿!,¿!
Í
â
⛩
(ê!<ب
åÀc
å"$

à
á
â
àب


á c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


â
ò¹

ä
ê!
ä
å
Æ
±Ìù&•º
´
.I&�º

3futures do nothing unless you `.await` or poll themÁHLè

Åç
Îè

—é
éè
ç ùö±ù‚³ª

Åá&“»
ê©
½/سíïã

êëìòBDGIE4�
E
æ
æŠú^«
E
æ
湪
w$™
E
æ
æ”í

Ӓ


•í

�ö
yaDŸd¤†ì('‰I
Åî
Îï

—ð
îï
ð ù
±ù
¿c

³ª
'ö¿c

¹ª
'‚ê©
ñÀc
ñ

P
S
W
Z
¡£


ã
ä
å
ãê©


ä c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


å
ò¹

í
'‰
í
ñ
Å
³ª

¹ª

V

±]
Y(ös	(üs
Eù(¸{2G
Åô
Îõ

—ö
öôõ
 ù…±ù„ê©
‹�

]`Ÿ¢¦©ù(Ú•
SÁ(Ý•

E

ø
æ

ææ
æ
¢D
ê
ËD
E
ë±
E
ì
áD
E
½/سíïã
ø
Ö·

Ü·


Îù
—ú

ùú

9÷�~Ÿ¸}
÷
Ö·

Ü·

thisÁ!(Œ–
hkª­±´ù*¨Ý
Õ

1*¨Õ
QQ(Ýt




þEü
Åý

Îþ
—ÿ
þÿý
üÎì


�«
JÍì


–«
RǪ

þE1*¤Þ



Å
þEù)ÿÈ
�«

þE�«


Å –«

þE-û
û
ìE
€
ËD
E
�±
E
‚
áD
E
'@EŒúsà
þE

Å
�«

–«
'@EŒúsà

€�‚1*ÓÝ
éì+.25Íí
E
û
û
þE

Å�«


óú
E
û
û
þE–«




E
û
û„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


þEÚï
ù/¨Ý
Õ

1/¨Õ
Ui(®x


þE„
Å…

Ά
—‡
…
‡†„ôöY„÷X”÷1/¤Þ
¦÷ù.ÿÈ
»÷È÷Õ÷ƒ
ƒ
¼F
ˆ
ËD
E
‰±
E
Š
áD
E
"úL²˜®¬
þE

Å
�«

–«
"úL²˜®¬

ˆ‰Š1/ÓÝ
ÊÍ¸Î
E
ƒ
ƒ
þEšù×Ô
E
ƒ
ƒ
þE–«
öÚ
E
ƒ
ƒ„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


þEÚïù3•‡›

13ù…9(Ü}






Œ„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


Œê©

û
û
ìE
€
ËD
E
�±
E
‚
áD
E
'@EŒúsà
Œ
Å
³ª

¹ª


ó
13°‡
ó
‹
Å
³ª

¹ª

!3Ň)+ù7•‡›

17ù…Y(›�







Ž„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


Žê©
ƒ
ƒ
¼F
ˆ
ËD
E
‰±
E
Š
áD
E
"úL²˜®¬
Ž
Å
³ª

¹ª


ó
17°‡
ó
�
Å
³ª

¹ª

!7Ň)+ù;å½0OA;ñ½

þE�
Å‘

Î’
—“
’�‘
“ôöN
„÷M
È÷ù(݈
t�
�
»G
”
ëG
E
•
ËD
E
–±
E
—
áD
E
Ýmä%®¤“P
þE

Å
�«

–«
Ýmä%®¤“P

”•–—1;ú½¯
²
ñ
ô
ø
û
ù;ܾ<�;ܾ
E
�
�• 
• 

– 
Ê€
Fu
\»Ÿ


þE

E
�
�0
0
1AlwaysUnpinÁ

3ˆ

‰4ä\’ÎM

šùS
;
E
�
�0
0
1
µ„	

3ˆ

‰4ä\’ÎM

–«
š
i
E
�
�Úïù;ÿá
O
þE™
Åš

Λ
—œ
›™œš
ôö^„÷]“í




)
)
*PinnedFieldsOfHelperStructÁ

,ˆ

Úˆ3Clœ†

šƒ	(Á;ŒÁǪ
1;È¿š�Üßãæ©?ûéPy?�ê
E
�

�

š•Á?ûé�

š•š•!ù?Ïê6P
¥Ÿ

Ÿ¾Ï	?ÔêŒ"

é¤
¹?×êé¤
 ù?‘ëFP
Å¡
΢

—£
£¢
¡ ùÛ
±ùÚ
ê©
­
°
ï
ò
ö
ù
ùH•º
´
.IH�º


ÀìmLè

Å¥
Φ

—§
¥¦
§ ùö±ù‚ÃîáH“»
‘¬
)p1*ÙŽ¡}

¨©ªò;=@BE4�
Z
¤
¤Šú^«
Z
¤
¤¹ª
w$™
Z
¤
¤Úï(I‰n
Ŭ
έ

—®
­
®¬ ùâ±ùàÐðIöáðI‚‘¬
¯Àc
¯ÖØ



��


ç
è
é
瑬


è c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


é
ò¹

«
I‰
«
¯
Å
³ª

¹ª

B

±I
YJös	Jüs
ZùJ¸{2l
Ų
γ

—´
´²³
 ùD±ùC‘¬
ÉË

#&^aehùJÚ•
SÁJÝ•

Z

¶
ê

ê¤
¤
€I
¨
ËD
Z
©±
Z
ª
áD
Z
)p1*ÙŽ¡}
¶
Ö·

Ü·


η
—¸

¸
·
ÿ÷�=Ÿ¸<
µ
Ö·

Ü·


Íô!JŒ–
+.fimpùL¨Ý
Õ

1L¨Õ
vQJÝt




þEº
Å»

μ
—½
º¼½»
ôöý„÷üê¬

þE1L¤Þ
¦÷ùKÿÈ
»÷È÷Õ÷¹
¹
ìE
¾
ËD
Z
¿±
Z
À
áD
Z
xVNBÅG+B
þE

Å
�«

–«
xVNBÅG+B

¾¿À1LÓÝ
|·º¾Á¸€
Z
¹
¹”ùÐ
Z
¹
¹ºùè~
Z
¹
¹ÚùùQ¨Ý
Õ

1Q¨Õ
ziJ®x


þEÂ
ÅÃ

ÎÄ
—Å
ÂÃ
ÅÄôö–„÷•£“	1Q¤Þ
¦÷ùPÿÈ
»÷È÷Õ÷Á
Á
¼F
Æ
ËD
Z
DZ
Z
È
áD
Z
?;øF
þE

Å
�«

–«
?;øF

ÆÇÈ1QÓÝ
ILPS¸
Z
Á
ÁõüÐ
Z
Á
Á”ýè
Z
Á
Á³ýùU•‡›

1Uù…9JÜ}






Ê„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


Ê‘¬

¹
¹
ìE
¾
ËD
Z
¿±
Z
À
áD
Z
xVNBÅG+B
Ê
Å
³ª

¹ª


±
1U°‡
±
É
Å
³ª

¹ª

!UŇ)+ùY•‡›

1Yù…YJ›�







Ì„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


Ì‘¬
Á
Á
¼F
Æ
ËD
Z
DZ
Z
È
áD
Z
?;øF
Ì
Å
³ª

¹ª


±
1Y°‡
±
Ë
Å
³ª

¹ª

!YŇ)+ù]å½0tA]ñ½

þEÎ
ÅÏ

ÎÐ
—Ñ
ÎÐÑÏ
ôöD	„÷C	È÷ùJ݈
tÍ
Í
»G
Ò
ëG
Z
Ó
ËD
Z
Ô±
Z
Õ
áD
Z
0·ä¯;ìµ
þE

Å
�«

–«
0·ä¯;ìµ

ÒÓÔÕ1]ú½¬	¯	ç	ê	î	ñ	ù]ܾ<�]ܾ
Z
Í
Íä„	ÕÒ	
Z
Í
ͪ…	íÑ	
Z
Í
Íû…	
Ñ	
Z
Í
ÍÚïù]ÿá
t
þE×
ÅØ

ÎÙ
—Ú
Ø
×ÙÚôö¿
„÷¾
“í




)
)
*
µ†	

,ˆ

Úˆ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.Á‹
,ù

¥ã
¦ä

ãä
¾Ïÿ

èˆ‚
‡¯
	—‰`Õµ

åæ(*-/áh“»
ž

o
â
⢻
Á

o
â
âï
Yiös	iüs
oùi¸{2�
¥é
¦ê

éê
¾ÏÅèˆǯ
úü

×ÙÜÞùiÚ•
SÁiÝ•

o

ë
뇯

¥ì
¦í

ìí

	i’–
¾Ïa
èˆ`

ë
é¤

ï


Íô!iŒ–
„
‡
‹
Ž
ùk¨Ý
Õ

1k¨Õ
—
QiÝt



þEï¥ð

¦ñ
ïð
ñÁ•Íì


ï®
±®

þE1k¤Þ
é®

þEùjÿÈ
ï®

þEî
î
ìE
ò¬
o
ó­
o
v�ÉL–ò¹
þE
é®

ï®
v�ÉL–ò¹

òó1kÓÝ
º½ÁÄš‘
o
î

„¾
ùõ


†¾‰
˜X
$]È=„kt•


þEÜ»

ëÉ
o
î

„¾
ùõ


†¾‰
˜X
$]È=„kt•


þEï®

ùo¨Ý
Õ

1o¨Õ
š
ii®x

þEõ¥ö

¦÷
÷õö
Á•æŒ©	圩	1o¤Þ
®©	ùnÿÈ
Á©	ô
ô
¼F
ø¬
o
ù­
o
ÙÄ;�®EþÅ
þE
é®

ï®
ÙÄ;�®EþÅ

øù1oÓÝ
tw{~“K
o
ô
ô„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


þEÜ»
äƒ
o
ô
ô„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


þEï®
ùr•‡›

1rù…9iÜ}





û„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


û‡¯

î
î
ìE
ò¬
o
ó­
o
v�ÉL–ò¹
û
é¤

ï


è
1r°‡
è
ú
é¤

ï

!rŇ#%ùu•‡›

1uù…Yi›�






ý„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ý‡¯
ô
ô
¼F
ø¬
o
ù­
o
ÙÄ;�®EþÅ
ý
é¤

ï


è
1u°‡
è
ü
é¤

ï

!uŇ#%ùxå½0•
Axñ½
þEÿ¥€

¦�
�€
ÿÁ•ŒŒ©	‹þ
þ
»G
‚
ëG
o
ƒ¬
o
„­
o
„Ðc,Ëzsw
þE
é®

ï®
„Ðc,Ëzsw

‚ƒ„1xú½

ùxܾ<�xܾ
o
þ
þä„	ùi݈
t	
o
þ
þÜ»

o
þ
þï®
ùxÿá
•

þE†¥‡

¦ˆ
†‡
ˆÁ•ÃŒ©	“í




)
)
*
µ†	

,ˆ

Úˆ3Clœ†

�´	(ÁxŒÁ±®
1xÈ¿"	%	)	,	©{ûé–
y{�ê
o
‰

‰

š•Á{ûé‰

š•š•!ù{Ïê6–

¥‹

‹¾Ï	{Ôê­‰	¹{×êé¤
ù{‘ëF–
¥�
¦Ž

�Ž
¾Ï
èˆ
‡¯

 
$
'
ù„
•º
´
.I„
�º


Àì®
<ץ�
¦‘

”’
’�‘
¾ÏßèˆâÍì


´°
åÚ¯
wNrx AÉÞ

“”•–=?BD>@á„
“»
4…
„

�
�é¤
 T˜
„

�
�´°
:<¯
„

�
�• 
• 

– 
Ê€
Fu
\»Ÿ

ï
{$°
„

�
�Úï(…
À¯
¥˜
¦™

”š
š˜™
¾Ï?
èˆ>
ټ	4
±¾…
ß¿c

ï
…
â¿c

´°
…
åÚ¯
›Àc
›�
�
”
—
’
•
ÁÃ

ì
í
î
ìÚ¯


í c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


î
ò¹

—
…
À
—
›
é¤

ï

´°

u

±|
Y†
ös	†
üs
„
ù†
¸{2­
¥ž
¦Ÿ

” 
žŸ
 ¾Ï×èˆÖŸº	ÌÚ¯
·¹

òõùü÷úù†
Ú•
SÁ†
Ý•

„


ï
ïÚ¯

¥¢
¦£

”¤
¤£
¢
	†
’–
¾Ï£èˆ¢Ÿº	˜
¡
é¤

ï

´°


Íô!†
Œ–
ÒÕÙÜ×Úùˆ
¨Ý
Õ

1ˆ
¨Õ
·
Q†
Ýt




þE¦¥§

¦¨
”©
©§
¦¨Á•~Œ©	}Íì


ϱ
|°

þE1ˆ
¤Þ
®©	ù‡
ÿÈ
ϱ

þEÁ©	¥
¥
ìE
ª
ËD
„

«
ôO
„

¬
†P
„

­
áD
„

‘æ%^ºŸ
þE
é®

ï®

ϱ
‘æ%^ºŸ

ª«¬­1ˆ
ÓÝ
UX\_Z]Ó
„

¥
¥„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


þEé®

%
Q
„

¥
¥
þEœ±

F
X
„

¥
¥
þE• 
• 

– 
Ê€
Fu
\»Ÿ

ï®

Ž
_
„

¥
¥ÚùùŽ
¨Ý
Õ

1Ž
¨Õ
¼
i†
®x

þE¯¥°

¦±
”²
²°
¯±Á•ÖŒ©	Õ›Ã	Ë«Ã	1Ž
¤Þ
®©	ù�
ÿÈ
ËÃ	
Á©	®
®
¼F
³
ËD
„

´
ôO
„

µ
†P
„

¶
áD
„

J–ÊI,^
þE
é®

ï®

ϱ
J–ÊI,^

³´µ¶1Ž
ÓÝ
–™� ›žÌY
„

®
®„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


þEé®

’
„

®
®
þEœ±
?
™
„

®
®
þE¤Æ	`
y
„

®
®³ýù“
•‡›

1“
ù…9†
Ü}






¸„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


¸Ú¯

¥
¥
ìE
ª
ËD
„

«
ôO
„

¬
†P
„

­
áD
„

‘æ%^ºŸ
¸
é¤

ï

´°


�
1“
°‡
�
·
é¤

ï

´°

!“
Ň)+ù˜
•‡›

1˜
ù…Y†
›�







º„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ºÚ¯
®
®
¼F
³
ËD
„

´
ôO
„

µ
†P
„

¶
áD
„

J–ÊI,^
º
é¤

ï

´°


�
1˜
°‡
�
¹
é¤

ï

´°

!˜
Ň)+ù�
å½0µ
A�
ñ½
þE¼¥½

¦¾
”¿
¿½
¾¼Á•+Œ©	*›Ã	 »
»
»G
À
ëG
„

Á
ËD
„

Â
ôO
„

Ã
†P
„

Ä
áD
„

"²oþ‘NÜ
þE
é®

ï®

ϱ
"²oþ‘NÜ

ÀÁÂÃÄ1�
ú½Ô×ÛÞÙÜù�
ܾ<��
ܾ
„

»
»ä„	ù†
݈
tÃ
„

»
»é®
 Â
„

»
»0
0
1
µ„	

3ˆ

‰4ä\’ÎM

ϱ
gï
„

»
»0
0
1
µ„	

3ˆ

‰4ä\’ÎM

¤Æ	®õ
„

»
»Úïù�
ÿá
µ

þEÆ¥Ç

¦È
Ӄ
ÈÆÇ
ÉÁ•@
Ω	?
›Ã	5
“í




)
)
*
µ†	

,ˆ

Úˆ3Clœ†

ÎÐ	(Á�
ŒÁ°
1�
È¿¨
«
¯
²
­
°
©¢
ûé¶
y¢
�ê
„

Ê

Ê

š•Á¢
ûéÊ

š•š•"ù¢
Ïê6¶

¥Ì

̾Ï	¢
Ôê­‰	¹¢
×êé¤
ù¢
‘ëF¶
¥Î
¦Ï

”Ð
ÎÐÏ
¾Ï»èˆºŸº	°Ú¯
ÐÓ×ÚÕØù¬
•º
´

ü–
GI¬
�º
D Stream returned by the [`filter`](super::StreamExt::filter) method.Á.Q
 streams do nothing unless polledÁÒ
4¢
ÎÒ
—Ó

ÒÓ
Ž¸©Ÿ¸­œ·

ȸÊ"àM!

ÔÕ(*-/á¬
“»
4É
Ó

Ñ
ÑÖ·
 Ý
Ó

Ñ
ÑÜ·
Y­
ös	­
üs
Ó
ù­
¸{2Ö

ÎØ
—Ù

ØÙ
Ž¸ÌŸ¸Êœ·
éë

Þàãåù­
Ú•
SÁ­
Ý•

Ó


ð
ðœ·


ÎÛ
—Ü

Ü
Û
	­
’–
Ž¸l
Ÿ¸k

Ú
Ö·

Ü·


Íô!­
Œ–
�
“
—
š
ù¯
¨Ý
Õ

1¯
¨Õ
Þ
Q­
Ýt



þEÞ
Îß

—à
àÞß
Íì


³ª
&±ù%ȶ

þE1¯
¤Þ
³ª

þEù®
ÿÈ
¹ª

þEÝ
Ý
ìE
á
ËD
Ó

â±
Ó

¢—D³'¶e…
þE
³ª

¹ª
¢—D³'¶e…

áâ1¯
ÓÝ
ÎÑÕØž¤
Ó

Ý
Ý„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


þE³ª

ðÜ
Ó

Ý
Ý
þE¹ª

ù³
¨Ý
Õ

1³
¨Õ
á
i­
®x

þEä
Îå

—æ
äå
æçÝ	ͱùÌþÝ	1³
¤Þ
‘Þ	ù²
ÿÈ
¥Þ	
ã
ã
¼F
ç
ËD
Ó

è±
Ó

d4}üáf‰å
þE
³ª

¹ª
d4}üáf‰å

çè1³
ÓÝ
`cgj—6
Ó

ã
ㄾ
„¾
ùõ


†¾‰
˜X
$]È=„kt•


þE³ª
én
Ó

ã
ã
þE¹ª
ù¶
•‡›

1¶
ù…9­
Ü}





ꄾ
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ꜷ

Ý
Ý
ìE
á
ËD
Ó

â±
Ó

¢—D³'¶e…
ê
Ö·

Ü·


×
1¶
°‡
×
é
Ö·

Ü·

!¶
Ň%'ù¹
•‡›

1¹
ù…Y­
›�






섾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


윷
ã
ã
¼F
ç
ËD
Ó

è±
Ó

d4}üáf‰å
ì
Ö·

Ü·


×
1¹
°‡
×
ë
Ö·

Ü·

!¹
Ň%'ù¼
å½0Ü
A¼
ñ½
þEî
Îï

—ð
ðîï
çÝ	X±ùWí
í
»G
ñ
ëG
Ó

ò
ËD
Ó

ó±
Ó

ëËx¢£Nè
þE
³ª

¹ª
ëËx¢£Nè

ñòó1¼
ú½ÚÝáäù¼
ܾ<�¼
ܾ
Ó

í
íä„	ù­
݈
tÜ
Ó

í
í³ª
 Û
Ó

í
í0
0
1
µ„	

3ˆ

‰4ä\’ÎM

¹ª
ù¼
ÿá
Ü

þEõ
Îö

—÷
÷ö
õçÝ	ȱùÇ“í




)
)
*
µ†	

,ˆ

Úˆ3Clœ†

¯è	(Á¼
ŒÁȶ
1¼
È¿)	,	0	3	©¿
ûéÝ
y¿
�ê
Ó

ø

ø

š•Á¿
ûéø

š•š•"ù¿
Ïê6Ý

¥ú

ú¾Ï	¿
Ôê­‰	¹¿
×êé¤
ù¿
‘ëFÝ

Îü
—ý

üý
Ž¸
Ÿ¸
œ·
,
/
3
6
ùÇ
•º
´

ü–
OIÇ
�º
L Stream returned by the [`filter_map`](super::StreamExt::filter_map) method.Á.Y

÷×	ï
Lª
Îÿ
—€	

€	
ÿŽ¸´Ÿ¸¸Ó¸
SŽ2€~ž_

�	‚	(*-/áÇ
“»
4Ô
ë

þ
þÖ·
 è
ë

þ
þÜ·
YÈ
ös	È
üs
ë
ùÈ
¸{2ó

Î…	
—†	

…	†	
Ž¸ÌŸ¸ÊÓ¸
–	˜	

ÞàãåùÈ
Ú•
SÁÈ
Ý•

ë


ñ
ñÓ¸


Έ	
—‰	

ˆ	‰	

	È
’–
Ž¸l
Ÿ¸k

‡	
Ö·

Ü·


Íô!È
Œ–
�
“
—
š
ùÊ
¨Ý
Õ

1Ê
¨Õ
û
QÈ
Ýt



þE‹	
Ό	

—�	
Œ	
�	‹	çÝ	±ùÿ·

þE1Ê
¤Þ
‘Þ	ùÉ
ÿÈ
¥Þ	
Š	
Š	
ìE
Ž	
ËD
ë

�	±
ë

fo\#Â1î
þE
³ª

¹ª
fo\#Â1î

Ž	�	1Ê
ÓÝ
·º¾Á—�
ë

Š	
Š	Ïß	°Œ
ë

Š	
Š	¡à	ùÎ
¨Ý
Õ

1Î
¨Õ
þ
iÈ
®x

þE‘	
Î’	

—“	
“	‘	’	
çÝ	v±ùuæó	1Î
¤Þ
‘Þ	ùÍ
ÿÈ
¥Þ	
�	
�	
¼F
”	
ËD
ë

•	±
ë

àGŠa® GŠ
þE
³ª

¹ª
àGŠa® GŠ

”	•	1Î
ÓÝ
	—ß
ë

�	
�	áâ	°Þ
ë

�	
�	³ã	ùÑ
•‡›

1Ñ
ù…9È
Ü}





—	„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


—	Ó¸

Š	
Š	
ìE
Ž	
ËD
ë

�	±
ë

fo\#Â1î
—	
Ö·

Ü·


„	
1Ñ
°‡
„	
–	
Ö·

Ü·

!Ñ
Ň%'ùÔ
•‡›

1Ô
ù…YÈ
›�






™	„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


™	Ó¸
�	
�	
¼F
”	
ËD
ë

•	±
ë

àGŠa® GŠ
™	
Ö·

Ü·


„	
1Ô
°‡
„	
˜	
Ö·

Ü·

!Ô
Ň%'ù×
å½0ù
A×
ñ½
þE›	
Μ	

—�	
œ	
›	�	çÝ	Á±ùÀš	
š	
»G
ž	
ëG
ë

Ÿ	
ËD
ë

 	±
ë

�‰ÝŒ‰¢ªt
þE
³ª

¹ª
�‰ÝŒ‰¢ªt

ž	Ÿ	 	1×
ú½CFJMù×
ܾ<�×
ܾ
ë

š	
š	ä„	ùÈ
݈
tE
ë

š	
š	³ª
 D
ë

š	
š	 ê	ù×
ÿá
ù

þE¢	
Σ	

—¤	
£	
¤	¢	çÝ	±ù“í




)
)
*
µ†	

,ˆ

Úˆ3Clœ†

‰ý	(Á×
ŒÁÿ·
1×
È¿dgkn©Ú
ûéú
yÚ
�ê
ë

¥	

¥	

š•ÁÚ
ûé¥	

š•š•"ùÚ
Ïê6ú

¥§	

§	¾Ï	Ú
Ôê­‰	¹Ú
×êé¤
ùÚ
‘ëFú

Ω	
—ª	

ª	
©	Ž¸Y	Ÿ¸X	Ó¸
g	j	n	q	ùã
•º
´
.Iã
�º


Àì’Tò
ά	
“­	

—®	
¬	®	­	
Ž¸ýÍÐ�±ù„±¹
¿>
•S‹

¯	°	±	²	469;>@áã
“»
4 
„
«	
«	Ö·
 ´
„
«	
«	Û¼ݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

‡º
Ì
„
«	
«	¹ª
™$º
„
«	
«	Úï(ä
““
δ	
“µ	

—¶	
¶	´	µ	
Ž¸T
ÍÐS
±ùR
°¸ä
ý¿c

‡º
ä
�áðä
„±¹
·	Àc
·	š
�
¡
¤
¨
«
¹»

ò
ó
ô
ò±¹


ó c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


ô
ò¹

³	
ä
“
³	
·	
Ö·

‡º

¹ª

m

±t
Yå
ös	å
üs
„ùå
¸{2‘
κ	
“»	

—¼	
»	
¼	º	Ž¸äÍÐã±ùâ±¹
Ó	Õ	

ÿ	
ùå
Ú•
SÁå
Ý•

„

õ
õ±¹


ξ	
“¿	

—À	
¿	
¾	À	
	å
’–
Ž¸°ÍЯ±ù®
½	
Ö·

‡º

¹ª


Íô!å
Œ–
ßâæéíðùç
¨Ý
Õ

1ç
¨Õ
›Qå
Ýt




þEÂ	
ÎÃ	

“Ä	
—Å	
Â	Ä	Å	Ã	
çÝ	‹Íì


ïº
“„÷’™º

þE1ç
¤Þ
‘Þ	ùæ
ÿÈ
ïº

þEÕ÷Á	
Á	
ìE
Æ	
ËD
„
Ç	
ÔY
„
È	±
„
É	
áD
„
éì`ÉIç
þE
³ª

ïº

–«
éì`ÉIç

Æ	Ç	È	É	1ç
ÓÝ
beilpsÓ.
„
Á	
Á	Ïß	ì-
„
Á	
Á	
þEÛ¼ݼ

Þ¼©

ß¼
à¼Û



Ἀ

cSñŸ«‡zÙ

ïº

Q
4
„
Á	
Á	ºùk
4
„
Á	
Á	Úùùí
¨Ý
Õ

1í
¨Õ
 iå
®x

þEË	
ÎÌ	

“Í	
—Î	
Ë	Í	Î	Ì	
çÝ	À¯Œ
¿„÷¾ÆŒ
1í
¤Þ
‘Þ	ùì
ÿÈ
æŒ

Õ÷Ê	
Ê	
¼F
Ï	
ËD
„
Ð	
ÔY
„
Ñ	±
„
Ò	
áD
„
¾±®q|"
þE
³ª

ïº

–«
¾±®q|"

Ï	Ð	Ñ	Ò	1í
ÓÝ
€ƒ‡ŠŽ‘ÌL
„
Ê	
Ê	áâ	åK
„
Ê	
Ê	
þEäŽ



„
Ê	
Ê	”ý


„
Ê	
Ê	³ýùò
•‡›

1ò
ù…9å
Ü}






Ô	„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


Ô	±¹

Á	
Á	
ìE
Æ	
ËD
„
Ç	
ÔY
„
È	±
„
É	
áD
„
éì`ÉIç
Ô	
Ö·

‡º

¹ª


¹	
1ò
°‡
¹	
Ó	
Ö·

‡º

¹ª

!ò
Ň)+ù÷
•‡›

1÷
ù…Yå
›�







Ö	„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


Ö	±¹
Ê	
Ê	
¼F
Ï	
ËD
„
Ð	
ÔY
„
Ñ	±
„
Ò	
áD
„
¾±®q|"
Ö	
Ö·

‡º

¹ª


¹	
1÷
°‡
¹	
Õ	
Ö·

‡º

¹ª

!÷
Ň)+ùü
å½0™Aü
ñ½
þEØ	
ÎÙ	

“Ú	
—Û	
Ú	Ø	Ù	
Û	çÝ	Ô
¯Œ
Ó
„÷Ò
×	
×	
»G
Ü	
ëG
„
Ý	
ËD
„
Þ	
ÔY
„
ß	±
„
à	
áD
„
ô^K¸C_
þE
³ª

ïº

–«
ô^K¸C_

Ü	Ý	Þ	ß	à	1ü
ú½}€„‡‹Žùü
ܾ<�ü
ܾ
„
×	
×	ä„	ùå
݈
tu
„
×	
×	³ª
 t
„
×	
×	0
0
1
µ„	

3ˆ

‰4ä\’ÎM

äŽ
g\
„
×	
×	û…	€[
„
×	
×	Úïùü
ÿá
™
þEâ	
Îã	

“ä	
—å	
å	ã	
â	ä	çÝ	»¯Œ
º„÷¹“í




)
)
*
µ†	

,ˆ

Úˆ3Clœ†

…™
(Áü
ŒÁ™º
1ü
È¿#
&
*
-
1
4
©�ûéšy��ê
„
æ	

æ	

š•Á�ûéæ	

š•š•"ù�Ïê6š
¥è	

è	¾Ï	�Ôê­‰	¹�×êé¤
ù�‘ëFš
Îê	
“ë	

—ì	
ì	ë	
ê	Ž¸6ÍÐ5±ù4±¹
KNRUY\ù‰•º
´

ü…
:I‰�º
7 Stream returned by [`fuse()`][super::StreamExt::fuse].Á»$ä

¥î	

î	
¾Ïé
¢»
Ÿéû+Ó² ¶



ï	 ቓ»
4…
š
í	

í	¾‘(ŠÍ
¼
¥ñ	

ñ	¾Ïs±¾Šé
¢»
ò	Àc
ò	Ž�PR

ö
÷
ø
ö¢»


÷ c
 cˆ

¢cµ

 `
£c
«²

 `
àB¤GS


ø
ò¹

ð	

ŠÍ

ð	
ò	

é¤

ú
±
Y‹ös	‹üs
šù‹¸{2º
¥õ	

õ	
¾Ï�
¢»
€
‚


œ
Ÿ
ù‹Ú•
SÁ‹Ý•

š

ù
ù¢»


¥÷	

÷	
	‹’–

¾Ï
ö	

é¤


Íô!‹Œ–
(+ù�¨Ý
Õ

1�¨Õ
ÄQ‹Ýt


þEù	¥ú	

ú	
ù	Á•–Ü»

þE1�¤Þ
®©	ùŒÿÈ
ø	
ø	
ìE

û	
ËD
š
aµˆ¦øT˜ 
þE
é®
aµˆ¦øT˜ 

û	1�ÓÝ
pï
š
ø	
ø	„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


þE·È
ù�¨Ý
Õ

1�¨Õ
Æi‹®x

þEý	¥þ	

ý	þ	
Á•Ñ«¦
1�¤Þ
®©	ù�ÿÈ
ü	
ü	
¼F

ÿ	
ËD
š
3æíû¹í
þE
é®
3æíû¹í

ÿ	1�ÓÝ
EHp#
š
ü	
ü	„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


þE·Èù’•‡›

1’ù…9‹Ü}




�
„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


�
¢»

ø	
ø	
ìE

û	
ËD
š
aµˆ¦øT˜ 
�

é¤


ô	

1’°‡
ô	
€


é¤

!’Ň!#ù”•‡›

1”ù…Y‹›�





ƒ
„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ƒ
¢»
ü	
ü	
¼F

ÿ	
ËD
š
3æíû¹í
ƒ

é¤


ô	

1”°‡
ô	
‚


é¤

!”Ň!#ù–å½0ÂA–ñ½
þE…
¥†


…
†


Á•Ô„

„

»G
‡

ëG
š
ˆ

ËD
š
wÏ‘šqЧ
þE
é®
wÏ‘šqЧ

‡
ˆ
1–ú½=@ù–ܾ<�–ܾ
š
„

„
ä„	ù‹݈
tG
š
„

„
·Èù–ÿá
Â
þEŠ
¥‹


Š
‹

Á•Æ“í




)
)
*
µ†	

,ˆ

Úˆ3Clœ†

è®
(Á–ŒÁÜ»
1–È¿ #©˜ûéÃy˜�ê
š
Œ


Œ


š•Á˜ûéŒ


š•š•"ù˜Ïê6Ã
¥Ž


Ž
¾Ï	˜Ôê­‰	¹˜×êé¤
ù˜‘ëFÃ
¥�


�

¾Ï÷¢»
þ
	ù •º
´

ü�
9I �º
6 Stream for the [`map`](super::StreamExt::map) method.Á.C

÷×	Ð�
Î’

—“


’
“

Ž¸‘Ÿ¸•Š½
Ö¯K‰´Êu

”
•
(*-/á “»
4±
«
‘

‘
Ö·
 Å
«
‘

‘
Ü·
Y¡ös	¡üs
«ù¡¸{2Ô
Θ

—™


™

˜
Ž¸ÌŸ¸ÊŠ½
©
«


Þàãåù¡Ú•
SÁ¡Ý•

«

ú
úŠ½


Λ

—œ


›
œ


	¡’–
Ž¸l
Ÿ¸k

š

Ö·

Ü·


Íô!¡Œ–
�
“
—
š
ù£¨Ý
Õ

1£¨Õ
ÜQ¡Ýt



þEž

Ο


— 

 
ž
Ÿ

çÝ	±ù¶¼

þE1£¤Þ
‘Þ	ù¢ÿÈ
¥Þ	
�

�

ìE
¡

ËD
«
¢
±
«
’•ó'è\)
þE
³ª

¹ª
’•ó'è\)

¡
¢
1£ÓÝ
·º¾Á—�
«
�

�
Ïß	°Œ
«
�

�
¡à	ù§¨Ý
Õ

1§¨Õ
ßi¡®x

þE¤

Î¥


—¦

¥

¦
¤
çÝ	v±ùu׸
1§¤Þ
‘Þ	ù¦ÿÈ
¥Þ	
£

£

¼F
§

ËD
«
¨
±
«
Î]E½²‘ð×
þE
³ª

¹ª
Î]E½²‘ð×

§
¨
1§ÓÝ
	—ß
«
£

£
áâ	°Þ
«
£

£
³ã	ùª•‡›

1ªù…9¡Ü}





ª
„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


ª
Š½

�

�

ìE
¡

ËD
«
¢
±
«
’•ó'è\)
ª

Ö·

Ü·


—

1ª°‡
—

©

Ö·

Ü·

!ªŇ%'ù­•‡›

1­ù…Y¡›�






¬
„¾
„¾
ùõ


†¾‰
˜X
$]È=„kt•


¬
Š½
£

£

¼F
§

ËD
«
¨
±
«
Î]E½²‘ð×
¬

Ö·

Ü·


—

1­°‡
—

«

Ö·

Ü·

!­Ň%'ù°å½0ÚA°ñ½
þE®

ί


—°

¯

°
®
çÝ	Á±ùÀ­

­

»G
±

ëG
«
²

ËD
«
³
±
«
ÙÂr41Ù�›
þE
³ª

¹ª
ÙÂr41Ù�›

±
²
³
1°ú½CFJMù°ܾ<�°ܾ
«
­

­
ä„	ù¡݈
tE
«
­

­
³ª
 D
«
­

­
 ê	ù°ÿá
Ú
þEµ

ζ


—·

·
µ
¶

çÝ	±ù“í




)
)
*
µ†	

,ˆ

Úˆ3Clœ†

úÁ
(Á°ŒÁ¶¼
1°È¿dgkn©³ûéÛy³�ê
«
¸


¸


š•Á³ûé¸


š•š•"ù³Ïê6Û
¥º


º
¾Ï	³Ôê­‰	¹³×êé¤
ù³‘ëFÛ
μ

—½


½

¼
Ž¸Y	Ÿ¸X	Š½
g	j	n	q	ùº•º
´

ü�
EIº�º
B Stream for the [`map_while`](super::StreamExt::map_while) method.Á.O

÷×	íD™
ο

—À


À

¿
Ž¸¢Ÿ¸¦½¾
¢«/à;ªz

Á
Â
(*-/ẓ»
4Â
Å
¾

¾
Ö·
 Ö
Å
¾

¾
Ü·
YȚs	ȟs
Åù»¸{2ñ
ÎÅ

—Æ


Å
Æ

Ž¸ÌŸ¸ʽ¾
Ö
Ø


Þàãåù»Ú•
SÁ»Ý•

Å

û
û½¾


ÎÈ

—É


É

È

	»’–
Ž¸l
Ÿ¸k

Ç

Ö·

Ü·


Íô!»Œ–
�
“
—
š
ù½¨Ý
Õ

1½¨Õ
ùQ»Ýt



þEË

ÎÌ


—Í

Ì

Ë
Í
çÝ	±ùé½

þE1½¤Þ
‘Þ	ù¼ÿÈ
¥Þ	
Ê

Ê

ìE
Î

ËD
Å
Ï
±
Å
H6ËA�A¡
þE
³ª

¹ª
H6ËA�A¡

Î
Ï
1½ÓÝ
·º¾Á—�
Å
Ê

Ê
Ïß	°Œ
Å
Ê